diff --git a/snix/build/protos/build.proto b/snix/build/protos/build.proto
index 5d42bded1..b399d9164 100644
--- a/snix/build/protos/build.proto
+++ b/snix/build/protos/build.proto
@@ -51,7 +51,7 @@ message BuildRequest {
   // As all references are content-addressed, no additional signatures are
   // needed to substitute / make these available in the build environment.
   // Inputs MUST be sorted by their names.
-  repeated snix.castore.v1.Node inputs = 1;
+  repeated snix.castore.v1.Entry inputs = 1;
 
   // The command (and its args) executed as the build script.
   // In the case of a Nix derivation, this is usually
@@ -161,7 +161,7 @@ message Build {
 
   // The outputs that were produced after successfully building.
   // They are sorted by their names.
-  repeated snix.castore.v1.Node outputs = 2;
+  repeated snix.castore.v1.Entry outputs = 2;
 
   message OutputNeedles {
     // The numbers are indexing into `refscan_needles` originally specified in the BuildRequest.
diff --git a/snix/build/src/buildservice/oci.rs b/snix/build/src/buildservice/oci.rs
index 82a24e19d..1651f2b27 100644
--- a/snix/build/src/buildservice/oci.rs
+++ b/snix/build/src/buildservice/oci.rs
@@ -216,7 +216,7 @@ where
                     };
 
                     Ok::<_, std::io::Error>((
-                        snix_castore::proto::Node::from_name_and_node(
+                        snix_castore::proto::Entry::from_name_and_node(
                             output_path
                                 .file_name()
                                 .and_then(|s| s.to_str())
diff --git a/snix/build/src/proto/mod.rs b/snix/build/src/proto/mod.rs
index c30968fa4..ec06450d1 100644
--- a/snix/build/src/proto/mod.rs
+++ b/snix/build/src/proto/mod.rs
@@ -149,7 +149,7 @@ impl From<crate::buildservice::BuildRequest> for BuildRequest {
                 .inputs
                 .into_iter()
                 .map(|(name, node)| {
-                    snix_castore::proto::Node::from_name_and_node(name.into(), node)
+                    snix_castore::proto::Entry::from_name_and_node(name.into(), node)
                 })
                 .collect(),
             command_args: value.command_args,
diff --git a/snix/castore-go/castore.go b/snix/castore-go/castore.go
index 40aeaf191..ef6e64bd5 100644
--- a/snix/castore-go/castore.go
+++ b/snix/castore-go/castore.go
@@ -51,8 +51,8 @@ func isValidName(n []byte) bool {
 	return true
 }
 
-// Validate ensures a DirectoryNode has a valid name and correct digest len.
-func (n *DirectoryNode) Validate() error {
+// Validate ensures a DirectoryEntry has a valid name and correct digest len.
+func (n *DirectoryEntry) Validate() error {
 	if len(n.Digest) != 32 {
 		return fmt.Errorf("invalid digest length for %s, expected %d, got %d", n.Name, 32, len(n.Digest))
 	}
@@ -64,8 +64,8 @@ func (n *DirectoryNode) Validate() error {
 	return nil
 }
 
-// Validate ensures a FileNode has a valid name and correct digest len.
-func (n *FileNode) Validate() error {
+// Validate ensures a FileEntry has a valid name and correct digest len.
+func (n *FileEntry) Validate() error {
 	if len(n.Digest) != 32 {
 		return fmt.Errorf("invalid digest length for %s, expected %d, got %d", n.Name, 32, len(n.Digest))
 	}
@@ -77,8 +77,8 @@ func (n *FileNode) Validate() error {
 	return nil
 }
 
-// Validate ensures a SymlinkNode has a valid name and target.
-func (n *SymlinkNode) Validate() error {
+// Validate ensures a SymlinkEntry has a valid name and target.
+func (n *SymlinkEntry) Validate() error {
 	if len(n.Target) == 0 || bytes.Contains(n.Target, []byte{0}) {
 		return fmt.Errorf("invalid symlink target: %s", n.Target)
 	}
@@ -91,7 +91,7 @@ func (n *SymlinkNode) Validate() error {
 }
 
 // Validate ensures a node is valid, by dispatching to the per-type validation functions.
-func (n *Node) Validate() error {
+func (n *Entry) Validate() error {
 	if node := n.GetDirectory(); node != nil {
 		if err := node.Validate(); err != nil {
 			return fmt.Errorf("SymlinkNode failed validation: %w", err)
diff --git a/snix/castore-go/castore.pb.go b/snix/castore-go/castore.pb.go
index 2eb9e6567..235427797 100644
--- a/snix/castore-go/castore.pb.go
+++ b/snix/castore-go/castore.pb.go
@@ -25,7 +25,7 @@ const (
 	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
 )
 
-// A Directory can contain Directory, File or Symlink nodes.
+// A Directory can contain Directory, File or Symlink entries.
 // Each of these nodes have a name attribute, which is the basename in that
 // directory and node type specific attributes.
 // The name attribute:
@@ -37,9 +37,9 @@ const (
 // attribute.
 type Directory struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
-	Directories   []*DirectoryNode       `protobuf:"bytes,1,rep,name=directories,proto3" json:"directories,omitempty"`
-	Files         []*FileNode            `protobuf:"bytes,2,rep,name=files,proto3" json:"files,omitempty"`
-	Symlinks      []*SymlinkNode         `protobuf:"bytes,3,rep,name=symlinks,proto3" json:"symlinks,omitempty"`
+	Directories   []*DirectoryEntry      `protobuf:"bytes,1,rep,name=directories,proto3" json:"directories,omitempty"`
+	Files         []*FileEntry           `protobuf:"bytes,2,rep,name=files,proto3" json:"files,omitempty"`
+	Symlinks      []*SymlinkEntry        `protobuf:"bytes,3,rep,name=symlinks,proto3" json:"symlinks,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
@@ -74,33 +74,33 @@ func (*Directory) Descriptor() ([]byte, []int) {
 	return file_snix_castore_protos_castore_proto_rawDescGZIP(), []int{0}
 }
 
-func (x *Directory) GetDirectories() []*DirectoryNode {
+func (x *Directory) GetDirectories() []*DirectoryEntry {
 	if x != nil {
 		return x.Directories
 	}
 	return nil
 }
 
-func (x *Directory) GetFiles() []*FileNode {
+func (x *Directory) GetFiles() []*FileEntry {
 	if x != nil {
 		return x.Files
 	}
 	return nil
 }
 
-func (x *Directory) GetSymlinks() []*SymlinkNode {
+func (x *Directory) GetSymlinks() []*SymlinkEntry {
 	if x != nil {
 		return x.Symlinks
 	}
 	return nil
 }
 
-// A DirectoryNode represents a directory in a Directory.
-type DirectoryNode struct {
+// A DirectoryEntry represents a directory.
+type DirectoryEntry struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// The (base)name of the directory
 	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
-	// The blake3 hash of a Directory message, serialized in protobuf canonical form.
+	// The blake3 digest of a Directory message.
 	Digest []byte `protobuf:"bytes,2,opt,name=digest,proto3" json:"digest,omitempty"`
 	// Number of child elements in the Directory referred to by `digest`.
 	// Calculated by summing up the numbers of `directories`, `files` and
@@ -117,20 +117,20 @@ type DirectoryNode struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *DirectoryNode) Reset() {
-	*x = DirectoryNode{}
+func (x *DirectoryEntry) Reset() {
+	*x = DirectoryEntry{}
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[1]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *DirectoryNode) String() string {
+func (x *DirectoryEntry) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*DirectoryNode) ProtoMessage() {}
+func (*DirectoryEntry) ProtoMessage() {}
 
-func (x *DirectoryNode) ProtoReflect() protoreflect.Message {
+func (x *DirectoryEntry) ProtoReflect() protoreflect.Message {
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[1]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -142,34 +142,34 @@ func (x *DirectoryNode) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use DirectoryNode.ProtoReflect.Descriptor instead.
-func (*DirectoryNode) Descriptor() ([]byte, []int) {
+// Deprecated: Use DirectoryEntry.ProtoReflect.Descriptor instead.
+func (*DirectoryEntry) Descriptor() ([]byte, []int) {
 	return file_snix_castore_protos_castore_proto_rawDescGZIP(), []int{1}
 }
 
-func (x *DirectoryNode) GetName() []byte {
+func (x *DirectoryEntry) GetName() []byte {
 	if x != nil {
 		return x.Name
 	}
 	return nil
 }
 
-func (x *DirectoryNode) GetDigest() []byte {
+func (x *DirectoryEntry) GetDigest() []byte {
 	if x != nil {
 		return x.Digest
 	}
 	return nil
 }
 
-func (x *DirectoryNode) GetSize() uint64 {
+func (x *DirectoryEntry) GetSize() uint64 {
 	if x != nil {
 		return x.Size
 	}
 	return 0
 }
 
-// A FileNode represents a regular or executable file in a Directory.
-type FileNode struct {
+// A FileEntry represents a regular or executable file.
+type FileEntry struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// The (base)name of the file
 	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
@@ -183,20 +183,20 @@ type FileNode struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *FileNode) Reset() {
-	*x = FileNode{}
+func (x *FileEntry) Reset() {
+	*x = FileEntry{}
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[2]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *FileNode) String() string {
+func (x *FileEntry) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*FileNode) ProtoMessage() {}
+func (*FileEntry) ProtoMessage() {}
 
-func (x *FileNode) ProtoReflect() protoreflect.Message {
+func (x *FileEntry) ProtoReflect() protoreflect.Message {
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[2]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -208,41 +208,41 @@ func (x *FileNode) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use FileNode.ProtoReflect.Descriptor instead.
-func (*FileNode) Descriptor() ([]byte, []int) {
+// Deprecated: Use FileEntry.ProtoReflect.Descriptor instead.
+func (*FileEntry) Descriptor() ([]byte, []int) {
 	return file_snix_castore_protos_castore_proto_rawDescGZIP(), []int{2}
 }
 
-func (x *FileNode) GetName() []byte {
+func (x *FileEntry) GetName() []byte {
 	if x != nil {
 		return x.Name
 	}
 	return nil
 }
 
-func (x *FileNode) GetDigest() []byte {
+func (x *FileEntry) GetDigest() []byte {
 	if x != nil {
 		return x.Digest
 	}
 	return nil
 }
 
-func (x *FileNode) GetSize() uint64 {
+func (x *FileEntry) GetSize() uint64 {
 	if x != nil {
 		return x.Size
 	}
 	return 0
 }
 
-func (x *FileNode) GetExecutable() bool {
+func (x *FileEntry) GetExecutable() bool {
 	if x != nil {
 		return x.Executable
 	}
 	return false
 }
 
-// A SymlinkNode represents a symbolic link in a Directory.
-type SymlinkNode struct {
+// A SymlinkEntry represents a symbolic link.
+type SymlinkEntry struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// The (base)name of the symlink
 	Name []byte `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
@@ -252,20 +252,20 @@ type SymlinkNode struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *SymlinkNode) Reset() {
-	*x = SymlinkNode{}
+func (x *SymlinkEntry) Reset() {
+	*x = SymlinkEntry{}
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[3]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *SymlinkNode) String() string {
+func (x *SymlinkEntry) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*SymlinkNode) ProtoMessage() {}
+func (*SymlinkEntry) ProtoMessage() {}
 
-func (x *SymlinkNode) ProtoReflect() protoreflect.Message {
+func (x *SymlinkEntry) ProtoReflect() protoreflect.Message {
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[3]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -277,52 +277,52 @@ func (x *SymlinkNode) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use SymlinkNode.ProtoReflect.Descriptor instead.
-func (*SymlinkNode) Descriptor() ([]byte, []int) {
+// Deprecated: Use SymlinkEntry.ProtoReflect.Descriptor instead.
+func (*SymlinkEntry) Descriptor() ([]byte, []int) {
 	return file_snix_castore_protos_castore_proto_rawDescGZIP(), []int{3}
 }
 
-func (x *SymlinkNode) GetName() []byte {
+func (x *SymlinkEntry) GetName() []byte {
 	if x != nil {
 		return x.Name
 	}
 	return nil
 }
 
-func (x *SymlinkNode) GetTarget() []byte {
+func (x *SymlinkEntry) GetTarget() []byte {
 	if x != nil {
 		return x.Target
 	}
 	return nil
 }
 
-// A Node is either a DirectoryNode, FileNode or SymlinkNode.
-type Node struct {
+// A Entry is either a DirectoryEntry, FileEntry or SymlinkEntry.
+type Entry struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
-	// Types that are valid to be assigned to Node:
+	// Types that are valid to be assigned to Entry:
 	//
-	//	*Node_Directory
-	//	*Node_File
-	//	*Node_Symlink
-	Node          isNode_Node `protobuf_oneof:"node"`
+	//	*Entry_Directory
+	//	*Entry_File
+	//	*Entry_Symlink
+	Entry         isEntry_Entry `protobuf_oneof:"entry"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *Node) Reset() {
-	*x = Node{}
+func (x *Entry) Reset() {
+	*x = Entry{}
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[4]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *Node) String() string {
+func (x *Entry) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*Node) ProtoMessage() {}
+func (*Entry) ProtoMessage() {}
 
-func (x *Node) ProtoReflect() protoreflect.Message {
+func (x *Entry) ProtoReflect() protoreflect.Message {
 	mi := &file_snix_castore_protos_castore_proto_msgTypes[4]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -334,66 +334,66 @@ func (x *Node) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use Node.ProtoReflect.Descriptor instead.
-func (*Node) Descriptor() ([]byte, []int) {
+// Deprecated: Use Entry.ProtoReflect.Descriptor instead.
+func (*Entry) Descriptor() ([]byte, []int) {
 	return file_snix_castore_protos_castore_proto_rawDescGZIP(), []int{4}
 }
 
-func (x *Node) GetNode() isNode_Node {
+func (x *Entry) GetEntry() isEntry_Entry {
 	if x != nil {
-		return x.Node
+		return x.Entry
 	}
 	return nil
 }
 
-func (x *Node) GetDirectory() *DirectoryNode {
+func (x *Entry) GetDirectory() *DirectoryEntry {
 	if x != nil {
-		if x, ok := x.Node.(*Node_Directory); ok {
+		if x, ok := x.Entry.(*Entry_Directory); ok {
 			return x.Directory
 		}
 	}
 	return nil
 }
 
-func (x *Node) GetFile() *FileNode {
+func (x *Entry) GetFile() *FileEntry {
 	if x != nil {
-		if x, ok := x.Node.(*Node_File); ok {
+		if x, ok := x.Entry.(*Entry_File); ok {
 			return x.File
 		}
 	}
 	return nil
 }
 
-func (x *Node) GetSymlink() *SymlinkNode {
+func (x *Entry) GetSymlink() *SymlinkEntry {
 	if x != nil {
-		if x, ok := x.Node.(*Node_Symlink); ok {
+		if x, ok := x.Entry.(*Entry_Symlink); ok {
 			return x.Symlink
 		}
 	}
 	return nil
 }
 
-type isNode_Node interface {
-	isNode_Node()
+type isEntry_Entry interface {
+	isEntry_Entry()
 }
 
-type Node_Directory struct {
-	Directory *DirectoryNode `protobuf:"bytes,1,opt,name=directory,proto3,oneof"`
+type Entry_Directory struct {
+	Directory *DirectoryEntry `protobuf:"bytes,1,opt,name=directory,proto3,oneof"`
 }
 
-type Node_File struct {
-	File *FileNode `protobuf:"bytes,2,opt,name=file,proto3,oneof"`
+type Entry_File struct {
+	File *FileEntry `protobuf:"bytes,2,opt,name=file,proto3,oneof"`
 }
 
-type Node_Symlink struct {
-	Symlink *SymlinkNode `protobuf:"bytes,3,opt,name=symlink,proto3,oneof"`
+type Entry_Symlink struct {
+	Symlink *SymlinkEntry `protobuf:"bytes,3,opt,name=symlink,proto3,oneof"`
 }
 
-func (*Node_Directory) isNode_Node() {}
+func (*Entry_Directory) isEntry_Entry() {}
 
-func (*Node_File) isNode_Node() {}
+func (*Entry_File) isEntry_Entry() {}
 
-func (*Node_Symlink) isNode_Node() {}
+func (*Entry_Symlink) isEntry_Entry() {}
 
 var File_snix_castore_protos_castore_proto protoreflect.FileDescriptor
 
@@ -401,48 +401,49 @@ var file_snix_castore_protos_castore_proto_rawDesc = string([]byte{
 	0x0a, 0x21, 0x73, 0x6e, 0x69, 0x78, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x70,
 	0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x70, 0x72,
 	0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72,
-	0x65, 0x2e, 0x76, 0x31, 0x22, 0xb8, 0x01, 0x0a, 0x09, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f,
-	0x72, 0x79, 0x12, 0x40, 0x0a, 0x0b, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65,
-	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63,
+	0x65, 0x2e, 0x76, 0x31, 0x22, 0xbb, 0x01, 0x0a, 0x09, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f,
+	0x72, 0x79, 0x12, 0x41, 0x0a, 0x0b, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x69, 0x65,
+	0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63,
 	0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74,
-	0x6f, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x0b, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f,
-	0x72, 0x69, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x02, 0x20,
-	0x03, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f,
-	0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x05,
-	0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x08, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b,
-	0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63,
-	0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6d, 0x6c, 0x69, 0x6e,
-	0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x08, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x73, 0x22,
-	0x4f, 0x0a, 0x0d, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65,
-	0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04,
-	0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65,
-	0x22, 0x6a, 0x0a, 0x08, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04,
-	0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65,
-	0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x12, 0x1e, 0x0a, 0x0a,
-	0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08,
-	0x52, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x39, 0x0a, 0x0b,
-	0x53, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x6e,
-	0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12,
-	0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52,
-	0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0xb9, 0x01, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65,
-	0x12, 0x3e, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f,
-	0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x4e,
-	0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79,
-	0x12, 0x2f, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19,
-	0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31,
-	0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x04, 0x66, 0x69, 0x6c,
-	0x65, 0x12, 0x38, 0x0a, 0x07, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x18, 0x03, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72,
-	0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x4e, 0x6f, 0x64, 0x65,
-	0x48, 0x00, 0x52, 0x07, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x42, 0x06, 0x0a, 0x04, 0x6e,
-	0x6f, 0x64, 0x65, 0x42, 0x22, 0x5a, 0x20, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x64, 0x65, 0x76, 0x2f,
-	0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3b, 0x63, 0x61,
-	0x73, 0x74, 0x6f, 0x72, 0x65, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74,
+	0x6f, 0x72, 0x69, 0x65, 0x73, 0x12, 0x30, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x02,
+	0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74,
+	0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79,
+	0x52, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x39, 0x0a, 0x08, 0x73, 0x79, 0x6d, 0x6c, 0x69,
+	0x6e, 0x6b, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x73, 0x6e, 0x69, 0x78,
+	0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79, 0x6d, 0x6c,
+	0x69, 0x6e, 0x6b, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x08, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e,
+	0x6b, 0x73, 0x22, 0x50, 0x0a, 0x0e, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x45,
+	0x6e, 0x74, 0x72, 0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01,
+	0x28, 0x0c, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65,
+	0x73, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74,
+	0x12, 0x12, 0x0a, 0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04,
+	0x73, 0x69, 0x7a, 0x65, 0x22, 0x6b, 0x0a, 0x09, 0x46, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x64, 0x69, 0x67, 0x65, 0x73, 0x74, 0x12, 0x12, 0x0a,
+	0x04, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x73, 0x69, 0x7a,
+	0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x18,
+	0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x61, 0x62, 0x6c,
+	0x65, 0x22, 0x3a, 0x0a, 0x0c, 0x53, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x45, 0x6e, 0x74, 0x72,
+	0x79, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18,
+	0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x06, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0xbe, 0x01,
+	0x0a, 0x05, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x3f, 0x0a, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63,
+	0x74, 0x6f, 0x72, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x73, 0x6e, 0x69,
+	0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x44, 0x69, 0x72,
+	0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x48, 0x00, 0x52, 0x09, 0x64,
+	0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x12, 0x30, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x63, 0x61,
+	0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x45, 0x6e, 0x74,
+	0x72, 0x79, 0x48, 0x00, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x39, 0x0a, 0x07, 0x73, 0x79,
+	0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x73, 0x6e,
+	0x69, 0x78, 0x2e, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x79,
+	0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x48, 0x00, 0x52, 0x07, 0x73, 0x79,
+	0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x42, 0x07, 0x0a, 0x05, 0x65, 0x6e, 0x74, 0x72, 0x79, 0x42, 0x22,
+	0x5a, 0x20, 0x73, 0x6e, 0x69, 0x78, 0x2e, 0x64, 0x65, 0x76, 0x2f, 0x63, 0x61, 0x73, 0x74, 0x6f,
+	0x72, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x3b, 0x63, 0x61, 0x73, 0x74, 0x6f, 0x72, 0x65,
+	0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 })
 
 var (
@@ -459,19 +460,19 @@ func file_snix_castore_protos_castore_proto_rawDescGZIP() []byte {
 
 var file_snix_castore_protos_castore_proto_msgTypes = make([]protoimpl.MessageInfo, 5)
 var file_snix_castore_protos_castore_proto_goTypes = []any{
-	(*Directory)(nil),     // 0: snix.castore.v1.Directory
-	(*DirectoryNode)(nil), // 1: snix.castore.v1.DirectoryNode
-	(*FileNode)(nil),      // 2: snix.castore.v1.FileNode
-	(*SymlinkNode)(nil),   // 3: snix.castore.v1.SymlinkNode
-	(*Node)(nil),          // 4: snix.castore.v1.Node
+	(*Directory)(nil),      // 0: snix.castore.v1.Directory
+	(*DirectoryEntry)(nil), // 1: snix.castore.v1.DirectoryEntry
+	(*FileEntry)(nil),      // 2: snix.castore.v1.FileEntry
+	(*SymlinkEntry)(nil),   // 3: snix.castore.v1.SymlinkEntry
+	(*Entry)(nil),          // 4: snix.castore.v1.Entry
 }
 var file_snix_castore_protos_castore_proto_depIdxs = []int32{
-	1, // 0: snix.castore.v1.Directory.directories:type_name -> snix.castore.v1.DirectoryNode
-	2, // 1: snix.castore.v1.Directory.files:type_name -> snix.castore.v1.FileNode
-	3, // 2: snix.castore.v1.Directory.symlinks:type_name -> snix.castore.v1.SymlinkNode
-	1, // 3: snix.castore.v1.Node.directory:type_name -> snix.castore.v1.DirectoryNode
-	2, // 4: snix.castore.v1.Node.file:type_name -> snix.castore.v1.FileNode
-	3, // 5: snix.castore.v1.Node.symlink:type_name -> snix.castore.v1.SymlinkNode
+	1, // 0: snix.castore.v1.Directory.directories:type_name -> snix.castore.v1.DirectoryEntry
+	2, // 1: snix.castore.v1.Directory.files:type_name -> snix.castore.v1.FileEntry
+	3, // 2: snix.castore.v1.Directory.symlinks:type_name -> snix.castore.v1.SymlinkEntry
+	1, // 3: snix.castore.v1.Entry.directory:type_name -> snix.castore.v1.DirectoryEntry
+	2, // 4: snix.castore.v1.Entry.file:type_name -> snix.castore.v1.FileEntry
+	3, // 5: snix.castore.v1.Entry.symlink:type_name -> snix.castore.v1.SymlinkEntry
 	6, // [6:6] is the sub-list for method output_type
 	6, // [6:6] is the sub-list for method input_type
 	6, // [6:6] is the sub-list for extension type_name
@@ -485,9 +486,9 @@ func file_snix_castore_protos_castore_proto_init() {
 		return
 	}
 	file_snix_castore_protos_castore_proto_msgTypes[4].OneofWrappers = []any{
-		(*Node_Directory)(nil),
-		(*Node_File)(nil),
-		(*Node_Symlink)(nil),
+		(*Entry_Directory)(nil),
+		(*Entry_File)(nil),
+		(*Entry_Symlink)(nil),
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
diff --git a/snix/castore-go/castore_test.go b/snix/castore-go/castore_test.go
index 1b9ad2ca0..1e41eda53 100644
--- a/snix/castore-go/castore_test.go
+++ b/snix/castore-go/castore_test.go
@@ -18,9 +18,9 @@ var (
 func TestDirectorySize(t *testing.T) {
 	t.Run("empty", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{},
-			Files:       []*castorev1pb.FileNode{},
-			Symlinks:    []*castorev1pb.SymlinkNode{},
+			Directories: []*castorev1pb.DirectoryEntry{},
+			Files:       []*castorev1pb.FileEntry{},
+			Symlinks:    []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.Equal(t, uint64(0), d.Size())
@@ -28,13 +28,13 @@ func TestDirectorySize(t *testing.T) {
 
 	t.Run("containing single empty directory", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{{
+			Directories: []*castorev1pb.DirectoryEntry{{
 				Name:   []byte([]byte("foo")),
 				Digest: dummyDigest,
 				Size:   0,
 			}},
-			Files:    []*castorev1pb.FileNode{},
-			Symlinks: []*castorev1pb.SymlinkNode{},
+			Files:    []*castorev1pb.FileEntry{},
+			Symlinks: []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.Equal(t, uint64(1), d.Size())
@@ -42,13 +42,13 @@ func TestDirectorySize(t *testing.T) {
 
 	t.Run("containing single non-empty directory", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{{
+			Directories: []*castorev1pb.DirectoryEntry{{
 				Name:   []byte("foo"),
 				Digest: dummyDigest,
 				Size:   4,
 			}},
-			Files:    []*castorev1pb.FileNode{},
-			Symlinks: []*castorev1pb.SymlinkNode{},
+			Files:    []*castorev1pb.FileEntry{},
+			Symlinks: []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.Equal(t, uint64(5), d.Size())
@@ -56,14 +56,14 @@ func TestDirectorySize(t *testing.T) {
 
 	t.Run("containing single file", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{},
-			Files: []*castorev1pb.FileNode{{
+			Directories: []*castorev1pb.DirectoryEntry{},
+			Files: []*castorev1pb.FileEntry{{
 				Name:       []byte("foo"),
 				Digest:     dummyDigest,
 				Size:       42,
 				Executable: false,
 			}},
-			Symlinks: []*castorev1pb.SymlinkNode{},
+			Symlinks: []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.Equal(t, uint64(1), d.Size())
@@ -71,9 +71,9 @@ func TestDirectorySize(t *testing.T) {
 
 	t.Run("containing single symlink", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{},
-			Files:       []*castorev1pb.FileNode{},
-			Symlinks: []*castorev1pb.SymlinkNode{{
+			Directories: []*castorev1pb.DirectoryEntry{},
+			Files:       []*castorev1pb.FileEntry{},
+			Symlinks: []*castorev1pb.SymlinkEntry{{
 				Name:   []byte("foo"),
 				Target: []byte("bar"),
 			}},
@@ -85,9 +85,9 @@ func TestDirectorySize(t *testing.T) {
 }
 func TestDirectoryDigest(t *testing.T) {
 	d := castorev1pb.Directory{
-		Directories: []*castorev1pb.DirectoryNode{},
-		Files:       []*castorev1pb.FileNode{},
-		Symlinks:    []*castorev1pb.SymlinkNode{},
+		Directories: []*castorev1pb.DirectoryEntry{},
+		Files:       []*castorev1pb.FileEntry{},
+		Symlinks:    []*castorev1pb.SymlinkEntry{},
 	}
 
 	dgst, err := d.Digest()
@@ -102,9 +102,9 @@ func TestDirectoryDigest(t *testing.T) {
 func TestDirectoryValidate(t *testing.T) {
 	t.Run("empty", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{},
-			Files:       []*castorev1pb.FileNode{},
-			Symlinks:    []*castorev1pb.SymlinkNode{},
+			Directories: []*castorev1pb.DirectoryEntry{},
+			Files:       []*castorev1pb.FileEntry{},
+			Symlinks:    []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.NoError(t, d.Validate())
@@ -113,49 +113,49 @@ func TestDirectoryValidate(t *testing.T) {
 	t.Run("invalid names", func(t *testing.T) {
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte{},
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files:    []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Files:    []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 
 			assert.ErrorContains(t, d.Validate(), "invalid node name")
 		}
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte("."),
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files:    []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Files:    []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 
 			assert.ErrorContains(t, d.Validate(), "invalid node name")
 		}
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{},
-				Files: []*castorev1pb.FileNode{{
+				Directories: []*castorev1pb.DirectoryEntry{},
+				Files: []*castorev1pb.FileEntry{{
 					Name:       []byte(".."),
 					Digest:     dummyDigest,
 					Size:       42,
 					Executable: false,
 				}},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 
 			assert.ErrorContains(t, d.Validate(), "invalid node name")
 		}
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{},
-				Files:       []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{{
+				Directories: []*castorev1pb.DirectoryEntry{},
+				Files:       []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{{
 					Name:   []byte("\x00"),
 					Target: []byte("foo"),
 				}},
@@ -165,9 +165,9 @@ func TestDirectoryValidate(t *testing.T) {
 		}
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{},
-				Files:       []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{{
+				Directories: []*castorev1pb.DirectoryEntry{},
+				Files:       []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{{
 					Name:   []byte("foo/bar"),
 					Target: []byte("foo"),
 				}},
@@ -179,13 +179,13 @@ func TestDirectoryValidate(t *testing.T) {
 
 	t.Run("invalid digest", func(t *testing.T) {
 		d := castorev1pb.Directory{
-			Directories: []*castorev1pb.DirectoryNode{{
+			Directories: []*castorev1pb.DirectoryEntry{{
 				Name:   []byte("foo"),
 				Digest: nil,
 				Size:   42,
 			}},
-			Files:    []*castorev1pb.FileNode{},
-			Symlinks: []*castorev1pb.SymlinkNode{},
+			Files:    []*castorev1pb.FileEntry{},
+			Symlinks: []*castorev1pb.SymlinkEntry{},
 		}
 
 		assert.ErrorContains(t, d.Validate(), "invalid digest length")
@@ -194,9 +194,9 @@ func TestDirectoryValidate(t *testing.T) {
 	t.Run("invalid symlink targets", func(t *testing.T) {
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{},
-				Files:       []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{{
+				Directories: []*castorev1pb.DirectoryEntry{},
+				Files:       []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{{
 					Name:   []byte("foo"),
 					Target: []byte{},
 				}},
@@ -206,9 +206,9 @@ func TestDirectoryValidate(t *testing.T) {
 		}
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{},
-				Files:       []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{{
+				Directories: []*castorev1pb.DirectoryEntry{},
+				Files:       []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{{
 					Name:   []byte("foo"),
 					Target: []byte{0x66, 0x6f, 0x6f, 0},
 				}},
@@ -222,7 +222,7 @@ func TestDirectoryValidate(t *testing.T) {
 		// "b" comes before "a", bad.
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte("b"),
 					Digest: dummyDigest,
 					Size:   42,
@@ -231,8 +231,8 @@ func TestDirectoryValidate(t *testing.T) {
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files:    []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Files:    []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 			assert.ErrorContains(t, d.Validate(), "is not in sorted order")
 		}
@@ -240,18 +240,18 @@ func TestDirectoryValidate(t *testing.T) {
 		// "a" exists twice, bad.
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte("a"),
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files: []*castorev1pb.FileNode{{
+				Files: []*castorev1pb.FileEntry{{
 					Name:       []byte("a"),
 					Digest:     dummyDigest,
 					Size:       42,
 					Executable: false,
 				}},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 			assert.ErrorContains(t, d.Validate(), "duplicate name")
 		}
@@ -259,7 +259,7 @@ func TestDirectoryValidate(t *testing.T) {
 		// "a" comes before "b", all good.
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte("a"),
 					Digest: dummyDigest,
 					Size:   42,
@@ -268,8 +268,8 @@ func TestDirectoryValidate(t *testing.T) {
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files:    []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{},
+				Files:    []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{},
 			}
 			assert.NoError(t, d.Validate(), "shouldn't error")
 		}
@@ -277,7 +277,7 @@ func TestDirectoryValidate(t *testing.T) {
 		// [b, c] and [a] are both properly sorted.
 		{
 			d := castorev1pb.Directory{
-				Directories: []*castorev1pb.DirectoryNode{{
+				Directories: []*castorev1pb.DirectoryEntry{{
 					Name:   []byte("b"),
 					Digest: dummyDigest,
 					Size:   42,
@@ -286,8 +286,8 @@ func TestDirectoryValidate(t *testing.T) {
 					Digest: dummyDigest,
 					Size:   42,
 				}},
-				Files: []*castorev1pb.FileNode{},
-				Symlinks: []*castorev1pb.SymlinkNode{{
+				Files: []*castorev1pb.FileEntry{},
+				Symlinks: []*castorev1pb.SymlinkEntry{{
 					Name:   []byte("a"),
 					Target: []byte("foo"),
 				}},
diff --git a/snix/castore-go/rename_entry.go b/snix/castore-go/rename_entry.go
new file mode 100644
index 000000000..1df38031d
--- /dev/null
+++ b/snix/castore-go/rename_entry.go
@@ -0,0 +1,38 @@
+package castorev1
+
+// RenamedEntry returns an entry with a new name.
+func RenamedEntry(entry *Entry, name string) *Entry {
+	if directoryEntry := entry.GetDirectory(); directoryEntry != nil {
+		return &Entry{
+			Entry: &Entry_Directory{
+				Directory: &DirectoryEntry{
+					Name:   []byte(name),
+					Digest: directoryEntry.GetDigest(),
+					Size:   directoryEntry.GetSize(),
+				},
+			},
+		}
+	} else if fileEntry := entry.GetFile(); fileEntry != nil {
+		return &Entry{
+			Entry: &Entry_File{
+				File: &FileEntry{
+					Name:       []byte(name),
+					Digest:     fileEntry.GetDigest(),
+					Size:       fileEntry.GetSize(),
+					Executable: fileEntry.GetExecutable(),
+				},
+			},
+		}
+	} else if symlinkEntry := entry.GetSymlink(); symlinkEntry != nil {
+		return &Entry{
+			Entry: &Entry_Symlink{
+				Symlink: &SymlinkEntry{
+					Name:   []byte(name),
+					Target: symlinkEntry.GetTarget(),
+				},
+			},
+		}
+	} else {
+		panic("unreachable")
+	}
+}
diff --git a/snix/castore-go/rename_node.go b/snix/castore-go/rename_node.go
deleted file mode 100644
index 80537b16d..000000000
--- a/snix/castore-go/rename_node.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package castorev1
-
-// RenamedNode returns a node with a new name.
-func RenamedNode(node *Node, name string) *Node {
-	if directoryNode := node.GetDirectory(); directoryNode != nil {
-		return &Node{
-			Node: &Node_Directory{
-				Directory: &DirectoryNode{
-					Name:   []byte(name),
-					Digest: directoryNode.GetDigest(),
-					Size:   directoryNode.GetSize(),
-				},
-			},
-		}
-	} else if fileNode := node.GetFile(); fileNode != nil {
-		return &Node{
-			Node: &Node_File{
-				File: &FileNode{
-					Name:       []byte(name),
-					Digest:     fileNode.GetDigest(),
-					Size:       fileNode.GetSize(),
-					Executable: fileNode.GetExecutable(),
-				},
-			},
-		}
-	} else if symlinkNode := node.GetSymlink(); symlinkNode != nil {
-		return &Node{
-			Node: &Node_Symlink{
-				Symlink: &SymlinkNode{
-					Name:   []byte(name),
-					Target: symlinkNode.GetTarget(),
-				},
-			},
-		}
-	} else {
-		panic("unreachable")
-	}
-}
diff --git a/snix/castore/protos/castore.proto b/snix/castore/protos/castore.proto
index d511ea4d3..47f45c081 100644
--- a/snix/castore/protos/castore.proto
+++ b/snix/castore/protos/castore.proto
@@ -8,7 +8,7 @@ package snix.castore.v1;
 
 option go_package = "snix.dev/castore/proto;castorev1";
 
-// A Directory can contain Directory, File or Symlink nodes.
+// A Directory can contain Directory, File or Symlink entries.
 // Each of these nodes have a name attribute, which is the basename in that
 // directory and node type specific attributes.
 // The name attribute:
@@ -18,16 +18,16 @@ option go_package = "snix.dev/castore/proto;castorev1";
 // Elements in each list need to be lexicographically ordered by the name
 // attribute.
 message Directory {
-  repeated DirectoryNode directories = 1;
-  repeated FileNode files = 2;
-  repeated SymlinkNode symlinks = 3;
+  repeated DirectoryEntry directories = 1;
+  repeated FileEntry files = 2;
+  repeated SymlinkEntry symlinks = 3;
 }
 
-// A DirectoryNode represents a directory in a Directory.
-message DirectoryNode {
+// A DirectoryEntry represents a directory.
+message DirectoryEntry {
   // The (base)name of the directory
   bytes name = 1;
-  // The blake3 hash of a Directory message, serialized in protobuf canonical form.
+  // The blake3 digest of a Directory message.
   bytes digest = 2;
   // Number of child elements in the Directory referred to by `digest`.
   // Calculated by summing up the numbers of `directories`, `files` and
@@ -42,8 +42,8 @@ message DirectoryNode {
   uint64 size = 3;
 }
 
-// A FileNode represents a regular or executable file in a Directory.
-message FileNode {
+// A FileEntry represents a regular or executable file.
+message FileEntry {
   // The (base)name of the file
   bytes name = 1;
   // The blake3 digest of the file contents
@@ -54,19 +54,19 @@ message FileNode {
   bool executable = 4;
 }
 
-// A SymlinkNode represents a symbolic link in a Directory.
-message SymlinkNode {
+// A SymlinkEntry represents a symbolic link.
+message SymlinkEntry {
   // The (base)name of the symlink
   bytes name = 1;
   // The target of the symlink.
   bytes target = 2;
 }
 
-// A Node is either a DirectoryNode, FileNode or SymlinkNode.
-message Node {
-  oneof node {
-    DirectoryNode directory = 1;
-    FileNode file = 2;
-    SymlinkNode symlink = 3;
+// A Entry is either a DirectoryEntry, FileEntry or SymlinkEntry.
+message Entry {
+  oneof entry {
+    DirectoryEntry directory = 1;
+    FileEntry file = 2;
+    SymlinkEntry symlink = 3;
   }
 }
diff --git a/snix/castore/src/errors.rs b/snix/castore/src/errors.rs
index 1c4605200..23b4822bf 100644
--- a/snix/castore/src/errors.rs
+++ b/snix/castore/src/errors.rs
@@ -59,9 +59,9 @@ pub enum DirectoryError {
     /// Elements are not in sorted order. Can only happen on protos
     #[error("{:?} is not sorted", .0.as_bstr())]
     WrongSorting(bytes::Bytes),
-    /// This can only happen if there's an unknown node type (on protos)
-    #[error("No node set")]
-    NoNodeSet,
+    /// This can only happen if there's an unknown entry type (on protos)
+    #[error("No entry set")]
+    NoEntrySet,
 }
 
 impl From<JoinError> for Error {
diff --git a/snix/castore/src/proto/mod.rs b/snix/castore/src/proto/mod.rs
index c98e8457e..f5e9c3d4d 100644
--- a/snix/castore/src/proto/mod.rs
+++ b/snix/castore/src/proto/mod.rs
@@ -121,8 +121,8 @@ impl TryFrom<Directory> for crate::Directory {
 
         for e in value.directories {
             elems.push(
-                Node {
-                    node: Some(node::Node::Directory(e)),
+                Entry {
+                    entry: Some(entry::Entry::Directory(e)),
                 }
                 .try_into_name_and_node()?,
             );
@@ -130,8 +130,8 @@ impl TryFrom<Directory> for crate::Directory {
 
         for e in value.files {
             elems.push(
-                Node {
-                    node: Some(node::Node::File(e)),
+                Entry {
+                    entry: Some(entry::Entry::File(e)),
                 }
                 .try_into_name_and_node()?,
             )
@@ -139,8 +139,8 @@ impl TryFrom<Directory> for crate::Directory {
 
         for e in value.symlinks {
             elems.push(
-                Node {
-                    node: Some(node::Node::Symlink(e)),
+                Entry {
+                    entry: Some(entry::Entry::Symlink(e)),
                 }
                 .try_into_name_and_node()?,
             )
@@ -162,19 +162,19 @@ impl From<crate::Directory> for Directory {
                     digest,
                     size,
                     executable,
-                } => files.push(FileNode {
+                } => files.push(FileEntry {
                     name: name.into(),
                     digest: digest.into(),
                     size,
                     executable,
                 }),
-                crate::Node::Directory { digest, size } => directories.push(DirectoryNode {
+                crate::Node::Directory { digest, size } => directories.push(DirectoryEntry {
                     name: name.into(),
                     digest: digest.into(),
                     size,
                 }),
                 crate::Node::Symlink { target } => {
-                    symlinks.push(SymlinkNode {
+                    symlinks.push(SymlinkEntry {
                         name: name.into(),
                         target: target.into(),
                     });
@@ -190,7 +190,7 @@ impl From<crate::Directory> for Directory {
     }
 }
 
-impl Node {
+impl Entry {
     /// Converts a proto [Node] to a [crate::Node], and splits off the name as a [PathComponent].
     pub fn try_into_name_and_node(self) -> Result<(PathComponent, crate::Node), DirectoryError> {
         let (name_bytes, node) = self.try_into_unchecked_name_and_checked_node()?;
@@ -205,8 +205,8 @@ impl Node {
     fn try_into_unchecked_name_and_checked_node(
         self,
     ) -> Result<(bytes::Bytes, crate::Node), DirectoryError> {
-        match self.node.ok_or_else(|| DirectoryError::NoNodeSet)? {
-            node::Node::Directory(n) => {
+        match self.entry.ok_or_else(|| DirectoryError::NoEntrySet)? {
+            entry::Entry::Directory(n) => {
                 let digest = B3Digest::try_from(n.digest)
                     .map_err(|e| DirectoryError::InvalidNode(n.name.clone(), e.into()))?;
 
@@ -217,7 +217,7 @@ impl Node {
 
                 Ok((n.name, node))
             }
-            node::Node::File(n) => {
+            entry::Entry::File(n) => {
                 let digest = B3Digest::try_from(n.digest)
                     .map_err(|e| DirectoryError::InvalidNode(n.name.clone(), e.into()))?;
 
@@ -230,7 +230,7 @@ impl Node {
                 Ok((n.name, node))
             }
 
-            node::Node::Symlink(n) => {
+            entry::Entry::Symlink(n) => {
                 let node = crate::Node::Symlink {
                     target: n.target.try_into().map_err(|e| {
                         DirectoryError::InvalidNode(
@@ -259,13 +259,13 @@ impl Node {
         Ok(node)
     }
 
-    /// Constructs a [Node] from a name and [crate::Node].
+    /// Constructs an [Entry] from a name and [crate::Node].
     /// The name is a [bytes::Bytes], not a [PathComponent], as we have use an
     /// empty name in some places.
     pub fn from_name_and_node(name: bytes::Bytes, n: crate::Node) -> Self {
         match n {
             crate::Node::Directory { digest, size } => Self {
-                node: Some(node::Node::Directory(DirectoryNode {
+                entry: Some(entry::Entry::Directory(DirectoryEntry {
                     name,
                     digest: digest.into(),
                     size,
@@ -276,7 +276,7 @@ impl Node {
                 size,
                 executable,
             } => Self {
-                node: Some(node::Node::File(FileNode {
+                entry: Some(entry::Entry::File(FileEntry {
                     name,
                     digest: digest.into(),
                     size,
@@ -284,7 +284,7 @@ impl Node {
                 })),
             },
             crate::Node::Symlink { target } => Self {
-                node: Some(node::Node::Symlink(SymlinkNode {
+                entry: Some(entry::Entry::Symlink(SymlinkEntry {
                     name,
                     target: target.into(),
                 })),
diff --git a/snix/castore/src/proto/tests/directory.rs b/snix/castore/src/proto/tests/directory.rs
index efbc4e9f2..8eb5c92a8 100644
--- a/snix/castore/src/proto/tests/directory.rs
+++ b/snix/castore/src/proto/tests/directory.rs
@@ -1,4 +1,4 @@
-use crate::proto::{Directory, DirectoryError, DirectoryNode, FileNode, SymlinkNode};
+use crate::proto::{Directory, DirectoryEntry, DirectoryError, FileEntry, SymlinkEntry};
 use crate::ValidateNodeError;
 
 use hex_literal::hex;
@@ -13,7 +13,7 @@ fn size() {
     }
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: "foo".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 0,
@@ -24,7 +24,7 @@ fn size() {
     }
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: "foo".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 4,
@@ -35,7 +35,7 @@ fn size() {
     }
     {
         let d = Directory {
-            files: vec![FileNode {
+            files: vec![FileEntry {
                 name: "foo".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 42,
@@ -47,7 +47,7 @@ fn size() {
     }
     {
         let d = Directory {
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: "foo".into(),
                 target: "bar".into(),
             }],
@@ -62,7 +62,7 @@ fn size() {
 #[should_panic = "Directory::size exceeds u64::MAX"]
 fn size_unchecked_panic() {
     let d = Directory {
-        directories: vec![DirectoryNode {
+        directories: vec![DirectoryEntry {
             name: "foo".into(),
             digest: DUMMY_DIGEST.to_vec().into(),
             size: u64::MAX,
@@ -77,7 +77,7 @@ fn size_unchecked_panic() {
 #[cfg_attr(debug_assertions, ignore)]
 fn size_unchecked_saturate() {
     let d = Directory {
-        directories: vec![DirectoryNode {
+        directories: vec![DirectoryEntry {
             name: "foo".into(),
             digest: DUMMY_DIGEST.to_vec().into(),
             size: u64::MAX,
@@ -94,7 +94,7 @@ fn size_checked() {
     // child count, since that would take an absurd amount of memory.
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: "foo".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: u64::MAX - 1,
@@ -105,7 +105,7 @@ fn size_checked() {
     }
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: "foo".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: u64::MAX,
@@ -117,12 +117,12 @@ fn size_checked() {
     {
         let d = Directory {
             directories: vec![
-                DirectoryNode {
+                DirectoryEntry {
                     name: "foo".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: u64::MAX / 2,
                 },
-                DirectoryNode {
+                DirectoryEntry {
                     name: "foo".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: u64::MAX / 2,
@@ -154,7 +154,7 @@ fn validate_empty() {
 fn validate_invalid_names() {
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: b"\0"[..].into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 42,
@@ -168,7 +168,7 @@ fn validate_invalid_names() {
 
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: ".".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 42,
@@ -181,7 +181,7 @@ fn validate_invalid_names() {
 
     {
         let d = Directory {
-            files: vec![FileNode {
+            files: vec![FileEntry {
                 name: "..".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 42,
@@ -195,7 +195,7 @@ fn validate_invalid_names() {
 
     {
         let d = Directory {
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: "\x00".into(),
                 target: "foo".into(),
             }],
@@ -207,7 +207,7 @@ fn validate_invalid_names() {
 
     {
         let d = Directory {
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: "foo/bar".into(),
                 target: "foo".into(),
             }],
@@ -219,7 +219,7 @@ fn validate_invalid_names() {
 
     {
         let d = Directory {
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: bytes::Bytes::copy_from_slice("X".repeat(500).into_bytes().as_slice()),
                 target: "foo".into(),
             }],
@@ -233,7 +233,7 @@ fn validate_invalid_names() {
 #[test]
 fn validate_invalid_digest() {
     let d = Directory {
-        directories: vec![DirectoryNode {
+        directories: vec![DirectoryEntry {
             name: "foo".into(),
             digest: vec![0x00, 0x42].into(), // invalid length
             size: 42,
@@ -254,12 +254,12 @@ fn validate_sorting() {
     {
         let d = Directory {
             directories: vec![
-                DirectoryNode {
+                DirectoryEntry {
                     name: "b".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
                 },
-                DirectoryNode {
+                DirectoryEntry {
                     name: "a".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
@@ -279,12 +279,12 @@ fn validate_sorting() {
     {
         let d = Directory {
             directories: vec![
-                DirectoryNode {
+                DirectoryEntry {
                     name: "a".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
                 },
-                DirectoryNode {
+                DirectoryEntry {
                     name: "a".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
@@ -303,12 +303,12 @@ fn validate_sorting() {
     // "a" exists twice (different types), bad.
     {
         let d = Directory {
-            directories: vec![DirectoryNode {
+            directories: vec![DirectoryEntry {
                 name: "a".into(),
                 digest: DUMMY_DIGEST.to_vec().into(),
                 size: 42,
             }],
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: "a".into(),
                 target: "b".into(),
             }],
@@ -326,12 +326,12 @@ fn validate_sorting() {
     {
         let d = Directory {
             directories: vec![
-                DirectoryNode {
+                DirectoryEntry {
                     name: "a".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
                 },
-                DirectoryNode {
+                DirectoryEntry {
                     name: "b".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
@@ -347,18 +347,18 @@ fn validate_sorting() {
     {
         let d = Directory {
             directories: vec![
-                DirectoryNode {
+                DirectoryEntry {
                     name: "b".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
                 },
-                DirectoryNode {
+                DirectoryEntry {
                     name: "c".into(),
                     digest: DUMMY_DIGEST.to_vec().into(),
                     size: 42,
                 },
             ],
-            symlinks: vec![SymlinkNode {
+            symlinks: vec![SymlinkEntry {
                 name: "a".into(),
                 target: "foo".into(),
             }],
diff --git a/snix/castore/src/proto/tests/mod.rs b/snix/castore/src/proto/tests/mod.rs
index 9f6330914..12cdc533d 100644
--- a/snix/castore/src/proto/tests/mod.rs
+++ b/snix/castore/src/proto/tests/mod.rs
@@ -1,13 +1,13 @@
-use super::{node, Node, SymlinkNode};
+use super::{entry, Entry, SymlinkEntry};
 use crate::DirectoryError;
 
 mod directory;
 
-/// Create a node with an empty symlink target, and ensure it fails validation.
+/// Create an entry with an empty symlink target, and ensure it fails validation.
 #[test]
 fn convert_symlink_empty_target_invalid() {
-    Node {
-        node: Some(node::Node::Symlink(SymlinkNode {
+    Entry {
+        entry: Some(entry::Entry::Symlink(SymlinkEntry {
             name: "foo".into(),
             target: "".into(),
         })),
@@ -20,8 +20,8 @@ fn convert_symlink_empty_target_invalid() {
 /// fails validation.
 #[test]
 fn convert_symlink_target_null_byte_invalid() {
-    Node {
-        node: Some(node::Node::Symlink(SymlinkNode {
+    Entry {
+        entry: Some(entry::Entry::Symlink(SymlinkEntry {
             name: "foo".into(),
             target: "foo\0".into(),
         })),
@@ -35,8 +35,8 @@ fn convert_symlink_target_null_byte_invalid() {
 fn convert_anonymous_with_name_fail() {
     assert_eq!(
         DirectoryError::NameInAnonymousNode,
-        Node {
-            node: Some(node::Node::Symlink(SymlinkNode {
+        Entry {
+            entry: Some(entry::Entry::Symlink(SymlinkEntry {
                 name: "foo".into(),
                 target: "somewhereelse".into(),
             })),
diff --git a/snix/nar-bridge/src/nar.rs b/snix/nar-bridge/src/nar.rs
index 41e6e8694..850354081 100644
--- a/snix/nar-bridge/src/nar.rs
+++ b/snix/nar-bridge/src/nar.rs
@@ -56,7 +56,7 @@ pub async fn get_head(
     }
 
     // parse the proto
-    let root_node: snix_castore::proto::Node = Message::decode(Bytes::from(root_node_proto))
+    let root_node: snix_castore::proto::Entry = Message::decode(Bytes::from(root_node_proto))
         .map_err(|e| {
             warn!(err=%e, "unable to decode root node proto");
             StatusCode::NOT_FOUND
@@ -244,8 +244,11 @@ mod tests {
     pub static NAR_STR_SYMLINK: LazyLock<String> = LazyLock::new(|| {
         use prost::Message;
         BASE64URL_NOPAD.encode(
-            &snix_castore::proto::Node::from_name_and_node("".into(), CASTORE_NODE_SYMLINK.clone())
-                .encode_to_vec(),
+            &snix_castore::proto::Entry::from_name_and_node(
+                "".into(),
+                CASTORE_NODE_SYMLINK.clone(),
+            )
+            .encode_to_vec(),
         )
     });
 
@@ -305,9 +308,9 @@ mod tests {
 
         let invalid_url = {
             use prost::Message;
-            let n = snix_castore::proto::Node {
-                node: Some(snix_castore::proto::node::Node::Directory(
-                    snix_castore::proto::DirectoryNode {
+            let n = snix_castore::proto::Entry {
+                entry: Some(snix_castore::proto::entry::Entry::Directory(
+                    snix_castore::proto::DirectoryEntry {
                         name: "".into(),
                         digest: "invalid b64".into(),
                         size: 1,
diff --git a/snix/nar-bridge/src/narinfo.rs b/snix/nar-bridge/src/narinfo.rs
index 64e7f4814..f6cf7d248 100644
--- a/snix/nar-bridge/src/narinfo.rs
+++ b/snix/nar-bridge/src/narinfo.rs
@@ -147,7 +147,7 @@ fn gen_narinfo_str(path_info: &PathInfo) -> String {
     let url = format!(
         "nar/snix-castore/{}?narsize={}",
         data_encoding::BASE64URL_NOPAD.encode(
-            &snix_castore::proto::Node::from_name_and_node("".into(), path_info.node.to_owned())
+            &snix_castore::proto::Entry::from_name_and_node("".into(), path_info.node.to_owned())
                 .encode_to_vec()
         ),
         path_info.nar_size,
diff --git a/snix/store/protos/pathinfo.proto b/snix/store/protos/pathinfo.proto
index 7f51746a6..120406d63 100644
--- a/snix/store/protos/pathinfo.proto
+++ b/snix/store/protos/pathinfo.proto
@@ -12,8 +12,9 @@ option go_package = "snix.dev/store/proto;storev1";
 // PathInfo shows information about a Nix Store Path.
 // That's a single element inside /nix/store.
 message PathInfo {
-  // The path can be a directory, file or symlink.
-  snix.castore.v1.Node node = 1;
+  // The entry both describes the store path and the contents, which can be a
+  // directory, file or symlink.
+  snix.castore.v1.Entry entry = 1;
 
   // List of references (output path hashes)
   // This really is the raw *bytes*, after decoding nixbase32, and not a
diff --git a/snix/store/protos/rpc_pathinfo.proto b/snix/store/protos/rpc_pathinfo.proto
index 147389c8e..7a5e788df 100644
--- a/snix/store/protos/rpc_pathinfo.proto
+++ b/snix/store/protos/rpc_pathinfo.proto
@@ -41,7 +41,7 @@ service PathInfoService {
   //
   // It can also be used to calculate arbitrary NAR hashes of output paths, in
   // case a legacy Nix Binary Cache frontend is provided.
-  rpc CalculateNAR(snix.castore.v1.Node) returns (CalculateNARResponse);
+  rpc CalculateNAR(snix.castore.v1.Entry) returns (CalculateNARResponse);
 
   // Return a stream of PathInfo messages matching the criteria specified in
   // ListPathInfoRequest.
diff --git a/snix/store/src/pathinfoservice/grpc.rs b/snix/store/src/pathinfoservice/grpc.rs
index 8f3d53602..ede86c7f2 100644
--- a/snix/store/src/pathinfoservice/grpc.rs
+++ b/snix/store/src/pathinfoservice/grpc.rs
@@ -128,7 +128,7 @@ where
         let path_info = self
             .grpc_client
             .clone()
-            .calculate_nar(snix_castore::proto::Node::from_name_and_node(
+            .calculate_nar(snix_castore::proto::Entry::from_name_and_node(
                 "".into(),
                 root_node.to_owned(),
             ))
diff --git a/snix/store/src/proto/grpc_pathinfoservice_wrapper.rs b/snix/store/src/proto/grpc_pathinfoservice_wrapper.rs
index 05697df95..d94049db7 100644
--- a/snix/store/src/proto/grpc_pathinfoservice_wrapper.rs
+++ b/snix/store/src/proto/grpc_pathinfoservice_wrapper.rs
@@ -75,7 +75,7 @@ where
     #[instrument(skip_all)]
     async fn calculate_nar(
         &self,
-        request: Request<castorepb::Node>,
+        request: Request<castorepb::Entry>,
     ) -> Result<Response<proto::CalculateNarResponse>> {
         let root_node = request
             .into_inner()
diff --git a/snix/store/src/proto/mod.rs b/snix/store/src/proto/mod.rs
index b9e3fa100..0cc294336 100644
--- a/snix/store/src/proto/mod.rs
+++ b/snix/store/src/proto/mod.rs
@@ -35,9 +35,9 @@ pub enum ValidatePathInfoError {
     #[error("Invalid length of digest at position {}, expected {}, got {}", .0, store_path::DIGEST_SIZE, .1)]
     InvalidReferenceDigestLen(usize, usize),
 
-    /// No node present
-    #[error("No node present")]
-    NoNodePresent,
+    /// No entry present
+    #[error("No entry present")]
+    NoEntryPresent,
 
     /// Node fails validation
     #[error("Invalid root node: {:?}", .0.to_string())]
@@ -181,7 +181,7 @@ impl From<&nix_compat::nixhash::CAHash> for nar_info::Ca {
 impl From<crate::pathinfoservice::PathInfo> for PathInfo {
     fn from(value: crate::pathinfoservice::PathInfo) -> Self {
         Self {
-            node: Some(castorepb::Node::from_name_and_node(
+            entry: Some(castorepb::Entry::from_name_and_node(
                 value.store_path.to_string().into_bytes().into(),
                 value.node,
             )),
@@ -270,10 +270,10 @@ impl TryFrom<PathInfo> for crate::pathinfoservice::PathInfo {
 
         let nar_sha256_length = narinfo.nar_sha256.len();
 
-        // split value.node into the name and node components
+        // split value.entry into the name and node components
         let (name, node) = value
-            .node
-            .ok_or_else(|| ValidatePathInfoError::NoNodePresent)?
+            .entry
+            .ok_or_else(|| ValidatePathInfoError::NoEntryPresent)?
             .try_into_name_and_node()
             .map_err(ValidatePathInfoError::InvalidRootNode)?;
 
diff --git a/snix/store/src/proto/tests/pathinfo.rs b/snix/store/src/proto/tests/pathinfo.rs
index f246eb5fb..015e88ab6 100644
--- a/snix/store/src/proto/tests/pathinfo.rs
+++ b/snix/store/src/proto/tests/pathinfo.rs
@@ -14,12 +14,14 @@ use snix_castore::{DirectoryError, ValidateNodeError};
 /// The references in `narinfo.reference_names` aligns with what's in
 /// `references`.
 static PROTO_PATH_INFO: LazyLock<proto::PathInfo> = LazyLock::new(|| proto::PathInfo {
-    node: Some(castorepb::Node {
-        node: Some(castorepb::node::Node::Directory(castorepb::DirectoryNode {
-            name: DUMMY_PATH_STR.into(),
-            digest: DUMMY_DIGEST.clone().into(),
-            size: 0,
-        })),
+    entry: Some(castorepb::Entry {
+        entry: Some(castorepb::entry::Entry::Directory(
+            castorepb::DirectoryEntry {
+                name: DUMMY_PATH_STR.into(),
+                digest: DUMMY_DIGEST.clone().into(),
+                size: 0,
+            },
+        )),
     }),
     references: vec![DUMMY_PATH_DIGEST.as_slice().into()],
     narinfo: Some(proto::NarInfo {
@@ -58,15 +60,15 @@ fn convert_valid_deriver() {
 }
 
 #[rstest]
-#[case::no_node(None, ValidatePathInfoError::NoNodePresent)]
-#[case::no_node_2(Some(castorepb::Node { node: None}), ValidatePathInfoError::InvalidRootNode(DirectoryError::NoNodeSet))]
-fn convert_pathinfo_wrong_nodes(
-    #[case] node: Option<castorepb::Node>,
+#[case::no_entry(None, ValidatePathInfoError::NoEntryPresent)]
+#[case::no_entry_2(Some(castorepb::Entry { entry: None}), ValidatePathInfoError::InvalidRootNode(DirectoryError::NoEntrySet))]
+fn convert_pathinfo_wrong_entries(
+    #[case] entry: Option<castorepb::Entry>,
     #[case] exp_err: ValidatePathInfoError,
 ) {
     // construct the PathInfo object
     let mut path_info = PROTO_PATH_INFO.clone();
-    path_info.node = node;
+    path_info.entry = entry;
 
     assert_eq!(
         exp_err,
@@ -74,19 +76,19 @@ fn convert_pathinfo_wrong_nodes(
     );
 }
 
-/// Constructs a [proto::PathInfo] with root nodes that have wrong data in
-/// various places, causing the conversion to [PathInfo] to fail.
+/// Constructs a [proto::PathInfo] with an entry that has wrong data in various
+/// places, causing the conversion to [PathInfo] to fail.
 #[rstest]
 #[case::directory_invalid_digest_length(
-    castorepb::node::Node::Directory(castorepb::DirectoryNode {
+    castorepb::entry::Entry::Directory(castorepb::DirectoryEntry {
         name: DUMMY_PATH_STR.into(),
         digest: Bytes::new(),
         size: 0,
     }),
     ValidatePathInfoError::InvalidRootNode(DirectoryError::InvalidNode(DUMMY_PATH_STR.into(), ValidateNodeError::InvalidDigestLen(0)))
 )]
-#[case::directory_invalid_node_name_no_storepath(
-    castorepb::node::Node::Directory(castorepb::DirectoryNode {
+#[case::directory_invalid_entry_name_no_storepath(
+    castorepb::entry::Entry::Directory(castorepb::DirectoryEntry {
         name: "invalid".into(),
         digest: DUMMY_DIGEST.clone().into(),
         size: 0,
@@ -94,15 +96,15 @@ fn convert_pathinfo_wrong_nodes(
     ValidatePathInfoError::InvalidNodeName("invalid".into(), store_path::Error::InvalidLength)
 )]
 #[case::file_invalid_digest_len(
-    castorepb::node::Node::File(castorepb::FileNode {
+    castorepb::entry::Entry::File(castorepb::FileEntry {
         name: DUMMY_PATH_STR.into(),
         digest: Bytes::new(),
         ..Default::default()
     }),
     ValidatePathInfoError::InvalidRootNode(DirectoryError::InvalidNode(DUMMY_PATH_STR.into(), ValidateNodeError::InvalidDigestLen(0)))
 )]
-#[case::file_invalid_node_name(
-    castorepb::node::Node::File(castorepb::FileNode {
+#[case::file_invalid_entry_name(
+    castorepb::entry::Entry::File(castorepb::FileEntry {
         name: "invalid".into(),
         digest: DUMMY_DIGEST.clone().into(),
         ..Default::default()
@@ -112,8 +114,8 @@ fn convert_pathinfo_wrong_nodes(
         store_path::Error::InvalidLength
     )
 )]
-#[case::symlink_invalid_node_name(
-    castorepb::node::Node::Symlink(castorepb::SymlinkNode {
+#[case::symlink_invalid_entry_name(
+    castorepb::entry::Entry::Symlink(castorepb::SymlinkEntry {
         name: "invalid".into(),
         target: "foo".into(),
     }),
@@ -122,10 +124,13 @@ fn convert_pathinfo_wrong_nodes(
         store_path::Error::InvalidLength
     )
 )]
-fn convert_fail_node(#[case] node: castorepb::node::Node, #[case] exp_err: ValidatePathInfoError) {
+fn convert_fail_entry(
+    #[case] entry: castorepb::entry::Entry,
+    #[case] exp_err: ValidatePathInfoError,
+) {
     // construct the proto::PathInfo object
     let mut p = PROTO_PATH_INFO.clone();
-    p.node = Some(castorepb::Node { node: Some(node) });
+    p.entry = Some(castorepb::Entry { entry: Some(entry) });
 
     assert_eq!(exp_err, PathInfo::try_from(p).expect_err("must fail"));
 }