From 645f1df93518a8522e735113eaf947eac421a911 Mon Sep 17 00:00:00 2001
From: Runxi Yu
Date: Tue, 10 Mar 2026 14:14:00 +0800
Subject: object/stored: Move from objectstored

---
 cmd/show-object/main.go       | 32 +++++++++++++++----------------
 object/stored/blob.go         | 35 ++++++++++++++++++++++++++++++++++
 object/stored/commit.go       | 32 +++++++++++++++++++++++++++++++
 object/stored/object.go       | 14 ++++++++++++++
 object/stored/objectstored.go | 32 +++++++++++++++++++++++++++++++
 object/stored/stored.go       |  2 ++
 object/stored/tree.go         | 32 +++++++++++++++++++++++++++++++
 objectstored/blob.go          | 35 ----------------------------------
 objectstored/commit.go        | 32 -------------------------------
 objectstored/object.go        | 14 --------------
 objectstored/objectstored.go  | 32 -------------------------------
 objectstored/stored.go        |  2 --
 objectstored/tree.go          | 32 -------------------------------
 repository/stored.go          | 44 +++++++++++++++++++++----------------------
 repository/tree.go            |  4 ++--
 15 files changed, 187 insertions(+), 187 deletions(-)
 create mode 100644 object/stored/blob.go
 create mode 100644 object/stored/commit.go
 create mode 100644 object/stored/object.go
 create mode 100644 object/stored/objectstored.go
 create mode 100644 object/stored/stored.go
 create mode 100644 object/stored/tree.go
 delete mode 100644 objectstored/blob.go
 delete mode 100644 objectstored/commit.go
 delete mode 100644 objectstored/object.go
 delete mode 100644 objectstored/objectstored.go
 delete mode 100644 objectstored/stored.go
 delete mode 100644 objectstored/tree.go

diff --git a/cmd/show-object/main.go b/cmd/show-object/main.go
index 94978db6..b50929a0 100644
--- a/cmd/show-object/main.go
+++ b/cmd/show-object/main.go
@@ -8,8 +8,8 @@ import (
 	"os"
 	"strings"
 
+	"codeberg.org/lindenii/furgit/object/stored"
 	"codeberg.org/lindenii/furgit/objectid"
-	"codeberg.org/lindenii/furgit/objectstored"
 	"codeberg.org/lindenii/furgit/objecttype"
 	"codeberg.org/lindenii/furgit/repository"
 )
@@ -50,14 +50,14 @@ func run(repoPath, name *string) error {
 		return fmt.Errorf("resolve %q: %w", *name, err)
 	}
 
-	stored, err := repo.ReadStored(id)
+	s, err := repo.ReadStored(id)
 	if err != nil {
 		_ = repo.Close()
 
 		return fmt.Errorf("read object %s: %w", id, err)
 	}
 
-	printStored(stored)
+	printStored(s)
 
 	err = repo.Close()
 	if err != nil {
@@ -81,11 +81,11 @@ func resolveInput(repo *repository.Repository, input string) (objectid.ObjectID,
 	return resolved.ID, nil
 }
 
-func printStored(stored objectstored.StoredObject) {
+func printStored(s stored.StoredObject) {
 	var b strings.Builder
 
-	id := stored.ID()
-	ty := stored.Object().ObjectType()
+	id := s.ID()
+	ty := s.Object().ObjectType()
 
 	tyName, ok := objecttype.Name(ty)
 	if !ok {
@@ -95,20 +95,20 @@ func printStored(stored objectstored.StoredObject) {
 	fmt.Fprintf(&b, "id: %s\n", id)
 	fmt.Fprintf(&b, "type: %s\n", tyName)
 
-	switch stored := stored.(type) {
-	case *objectstored.StoredBlob:
-		blob := stored.Blob()
+	switch s := s.(type) {
+	case *stored.StoredBlob:
+		blob := s.Blob()
 		fmt.Fprintf(&b, "size: %d\n", len(blob.Data))
 		fmt.Fprintf(&b, "data: %q\n", string(blob.Data))
-	case *objectstored.StoredTree:
-		tree := stored.Tree()
+	case *stored.StoredTree:
+		tree := s.Tree()
 		fmt.Fprintf(&b, "entries: %d\n", len(tree.Entries))
 
 		for _, entry := range tree.Entries {
 			fmt.Fprintf(&b, "%06o %s\t%s\n", entry.Mode, entry.ID, entry.Name)
 		}
-	case *objectstored.StoredCommit:
-		commit := stored.Commit()
+	case *stored.StoredCommit:
+		commit := s.Commit()
 		fmt.Fprintf(&b, "tree: %s\n", commit.Tree)
 
 		for _, parent := range commit.Parents {
@@ -118,8 +118,8 @@ func printStored(stored objectstored.StoredObject) {
 		fmt.Fprintf(&b, "author: %s <%s>\n", commit.Author.Name, commit.Author.Email)
 		fmt.Fprintf(&b, "committer: %s <%s>\n", commit.Committer.Name, commit.Committer.Email)
 		fmt.Fprintf(&b, "message:\n%s\n", string(commit.Message))
-	case *objectstored.StoredTag:
-		tag := stored.Tag()
+	case *stored.StoredTag:
+		tag := s.Tag()
 
 		targetTy, ok := objecttype.Name(tag.TargetType)
 		if !ok {
@@ -135,7 +135,7 @@ func printStored(stored objectstored.StoredObject) {
 
 		fmt.Fprintf(&b, "message:\n%s\n", string(tag.Message))
 	default:
-		fmt.Fprintf(&b, "%#v\n", stored.Object())
+		fmt.Fprintf(&b, "%#v\n", s.Object())
 	}
 
 	_, _ = os.Stdout.WriteString(b.String())
diff --git a/object/stored/blob.go b/object/stored/blob.go
new file mode 100644
index 00000000..4b3b6b74
--- /dev/null
+++ b/object/stored/blob.go
@@ -0,0 +1,35 @@
+package stored
+
+import (
+	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objectid"
+)
+
+// StoredBlob is a parsed blob paired with its storage ID.
+//
+// This Blob object is fully materialized in memory.
+// Consider using objectstore/Store.ReadReaderContent.
+type StoredBlob struct {
+	id   objectid.ObjectID
+	blob *object.Blob
+}
+
+// NewStoredBlob creates one stored blob wrapper.
+func NewStoredBlob(id objectid.ObjectID, blob *object.Blob) *StoredBlob {
+	return &StoredBlob{id: id, blob: blob}
+}
+
+// ID returns the object ID this blob was loaded from.
+func (stored *StoredBlob) ID() objectid.ObjectID {
+	return stored.id
+}
+
+// Object returns the parsed blob as the generic object interface.
+func (stored *StoredBlob) Object() object.Object {
+	return stored.blob
+}
+
+// Blob returns the parsed blob value.
+func (stored *StoredBlob) Blob() *object.Blob {
+	return stored.blob
+}
diff --git a/object/stored/commit.go b/object/stored/commit.go
new file mode 100644
index 00000000..880ba40c
--- /dev/null
+++ b/object/stored/commit.go
@@ -0,0 +1,32 @@
+package stored
+
+import (
+	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objectid"
+)
+
+// StoredCommit is a parsed commit paired with its storage ID.
+type StoredCommit struct {
+	id     objectid.ObjectID
+	commit *object.Commit
+}
+
+// NewStoredCommit creates one stored commit wrapper.
+func NewStoredCommit(id objectid.ObjectID, commit *object.Commit) *StoredCommit {
+	return &StoredCommit{id: id, commit: commit}
+}
+
+// ID returns the object ID this commit was loaded from.
+func (stored *StoredCommit) ID() objectid.ObjectID {
+	return stored.id
+}
+
+// Object returns the parsed commit as the generic object interface.
+func (stored *StoredCommit) Object() object.Object {
+	return stored.commit
+}
+
+// Commit returns the parsed commit value.
+func (stored *StoredCommit) Commit() *object.Commit {
+	return stored.commit
+}
diff --git a/object/stored/object.go b/object/stored/object.go
new file mode 100644
index 00000000..c0a0db8f
--- /dev/null
+++ b/object/stored/object.go
@@ -0,0 +1,14 @@
+package stored
+
+import (
+	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objectid"
+)
+
+// StoredObject is a parsed object paired with its storage ID.
+type StoredObject interface {
+	// ID returns the object ID the object was loaded from.
+	ID() objectid.ObjectID
+	// Object returns the parsed object value.
+	Object() object.Object
+}
diff --git a/object/stored/objectstored.go b/object/stored/objectstored.go
new file mode 100644
index 00000000..ff7d516a
--- /dev/null
+++ b/object/stored/objectstored.go
@@ -0,0 +1,32 @@
+package stored
+
+import (
+	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objectid"
+)
+
+// StoredTag is a parsed tag paired with its storage ID.
+type StoredTag struct {
+	id  objectid.ObjectID
+	tag *object.Tag
+}
+
+// NewStoredTag creates one stored tag wrapper.
+func NewStoredTag(id objectid.ObjectID, tag *object.Tag) *StoredTag {
+	return &StoredTag{id: id, tag: tag}
+}
+
+// ID returns the object ID this tag was loaded from.
+func (stored *StoredTag) ID() objectid.ObjectID {
+	return stored.id
+}
+
+// Object returns the parsed tag as the generic object interface.
+func (stored *StoredTag) Object() object.Object {
+	return stored.tag
+}
+
+// Tag returns the parsed tag value.
+func (stored *StoredTag) Tag() *object.Tag {
+	return stored.tag
+}
diff --git a/object/stored/stored.go b/object/stored/stored.go
new file mode 100644
index 00000000..588b1726
--- /dev/null
+++ b/object/stored/stored.go
@@ -0,0 +1,2 @@
+// Package stored wraps parsed objects with their storage object IDs.
+package stored
diff --git a/object/stored/tree.go b/object/stored/tree.go
new file mode 100644
index 00000000..a54c1f6e
--- /dev/null
+++ b/object/stored/tree.go
@@ -0,0 +1,32 @@
+package stored
+
+import (
+	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/objectid"
+)
+
+// StoredTree is a parsed tree paired with its storage ID.
+type StoredTree struct {
+	id   objectid.ObjectID
+	tree *object.Tree
+}
+
+// NewStoredTree creates one stored tree wrapper.
+func NewStoredTree(id objectid.ObjectID, tree *object.Tree) *StoredTree {
+	return &StoredTree{id: id, tree: tree}
+}
+
+// ID returns the object ID this tree was loaded from.
+func (stored *StoredTree) ID() objectid.ObjectID {
+	return stored.id
+}
+
+// Object returns the parsed tree as the generic object interface.
+func (stored *StoredTree) Object() object.Object {
+	return stored.tree
+}
+
+// Tree returns the parsed tree value.
+func (stored *StoredTree) Tree() *object.Tree {
+	return stored.tree
+}
diff --git a/objectstored/blob.go b/objectstored/blob.go
deleted file mode 100644
index 26584ce5..00000000
--- a/objectstored/blob.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package objectstored
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// StoredBlob is a parsed blob paired with its storage ID.
-//
-// This Blob object is fully materialized in memory.
-// Consider using objectstore/Store.ReadReaderContent.
-type StoredBlob struct {
-	id   objectid.ObjectID
-	blob *object.Blob
-}
-
-// NewStoredBlob creates one stored blob wrapper.
-func NewStoredBlob(id objectid.ObjectID, blob *object.Blob) *StoredBlob {
-	return &StoredBlob{id: id, blob: blob}
-}
-
-// ID returns the object ID this blob was loaded from.
-func (stored *StoredBlob) ID() objectid.ObjectID {
-	return stored.id
-}
-
-// Object returns the parsed blob as the generic object interface.
-func (stored *StoredBlob) Object() object.Object {
-	return stored.blob
-}
-
-// Blob returns the parsed blob value.
-func (stored *StoredBlob) Blob() *object.Blob {
-	return stored.blob
-}
diff --git a/objectstored/commit.go b/objectstored/commit.go
deleted file mode 100644
index 0bcd1e3f..00000000
--- a/objectstored/commit.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package objectstored
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// StoredCommit is a parsed commit paired with its storage ID.
-type StoredCommit struct {
-	id     objectid.ObjectID
-	commit *object.Commit
-}
-
-// NewStoredCommit creates one stored commit wrapper.
-func NewStoredCommit(id objectid.ObjectID, commit *object.Commit) *StoredCommit {
-	return &StoredCommit{id: id, commit: commit}
-}
-
-// ID returns the object ID this commit was loaded from.
-func (stored *StoredCommit) ID() objectid.ObjectID {
-	return stored.id
-}
-
-// Object returns the parsed commit as the generic object interface.
-func (stored *StoredCommit) Object() object.Object {
-	return stored.commit
-}
-
-// Commit returns the parsed commit value.
-func (stored *StoredCommit) Commit() *object.Commit {
-	return stored.commit
-}
diff --git a/objectstored/object.go b/objectstored/object.go
deleted file mode 100644
index 8099ddcd..00000000
--- a/objectstored/object.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package objectstored
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// StoredObject is a parsed object paired with its storage ID.
-type StoredObject interface {
-	// ID returns the object ID the object was loaded from.
-	ID() objectid.ObjectID
-	// Object returns the parsed object value.
-	Object() object.Object
-}
diff --git a/objectstored/objectstored.go b/objectstored/objectstored.go
deleted file mode 100644
index f50b27ee..00000000
--- a/objectstored/objectstored.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package objectstored
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// StoredTag is a parsed tag paired with its storage ID.
-type StoredTag struct {
-	id  objectid.ObjectID
-	tag *object.Tag
-}
-
-// NewStoredTag creates one stored tag wrapper.
-func NewStoredTag(id objectid.ObjectID, tag *object.Tag) *StoredTag {
-	return &StoredTag{id: id, tag: tag}
-}
-
-// ID returns the object ID this tag was loaded from.
-func (stored *StoredTag) ID() objectid.ObjectID {
-	return stored.id
-}
-
-// Object returns the parsed tag as the generic object interface.
-func (stored *StoredTag) Object() object.Object {
-	return stored.tag
-}
-
-// Tag returns the parsed tag value.
-func (stored *StoredTag) Tag() *object.Tag {
-	return stored.tag
-}
diff --git a/objectstored/stored.go b/objectstored/stored.go
deleted file mode 100644
index 96060295..00000000
--- a/objectstored/stored.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package objectstored wraps parsed objects with their storage object IDs.
-package objectstored
diff --git a/objectstored/tree.go b/objectstored/tree.go
deleted file mode 100644
index 3c6e53de..00000000
--- a/objectstored/tree.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package objectstored
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// StoredTree is a parsed tree paired with its storage ID.
-type StoredTree struct {
-	id   objectid.ObjectID
-	tree *object.Tree
-}
-
-// NewStoredTree creates one stored tree wrapper.
-func NewStoredTree(id objectid.ObjectID, tree *object.Tree) *StoredTree {
-	return &StoredTree{id: id, tree: tree}
-}
-
-// ID returns the object ID this tree was loaded from.
-func (stored *StoredTree) ID() objectid.ObjectID {
-	return stored.id
-}
-
-// Object returns the parsed tree as the generic object interface.
-func (stored *StoredTree) Object() object.Object {
-	return stored.tree
-}
-
-// Tree returns the parsed tree value.
-func (stored *StoredTree) Tree() *object.Tree {
-	return stored.tree
-}
diff --git a/repository/stored.go b/repository/stored.go
index d7ee5267..ca782cea 100644
--- a/repository/stored.go
+++ b/repository/stored.go
@@ -4,15 +4,15 @@ import (
 	"fmt"
 
 	"codeberg.org/lindenii/furgit/object"
+	"codeberg.org/lindenii/furgit/object/stored"
 	"codeberg.org/lindenii/furgit/objectid"
-	"codeberg.org/lindenii/furgit/objectstored"
 	"codeberg.org/lindenii/furgit/objecttype"
 )
 
 // ReadStored reads, parses, and wraps one object by ID.
 //
 //nolint:ireturn
-func (repo *Repository) ReadStored(id objectid.ObjectID) (objectstored.StoredObject, error) {
+func (repo *Repository) ReadStored(id objectid.ObjectID) (stored.StoredObject, error) {
 	parsed, err := repo.readParsedObject(id)
 	if err != nil {
 		return nil, err
@@ -20,73 +20,73 @@ func (repo *Repository) ReadStored(id objectid.ObjectID) (objectstored.StoredObj
 
 	switch parsed := parsed.(type) {
 	case *object.Blob:
-		return objectstored.NewStoredBlob(id, parsed), nil
+		return stored.NewStoredBlob(id, parsed), nil
 	case *object.Tree:
-		return objectstored.NewStoredTree(id, parsed), nil
+		return stored.NewStoredTree(id, parsed), nil
 	case *object.Commit:
-		return objectstored.NewStoredCommit(id, parsed), nil
+		return stored.NewStoredCommit(id, parsed), nil
 	case *object.Tag:
-		return objectstored.NewStoredTag(id, parsed), nil
+		return stored.NewStoredTag(id, parsed), nil
 	default:
 		return nil, fmt.Errorf("repository: unsupported parsed object type %T", parsed)
 	}
 }
 
 // ReadStoredBlob reads and parses a blob object by ID.
-func (repo *Repository) ReadStoredBlob(id objectid.ObjectID) (*objectstored.StoredBlob, error) {
-	stored, err := repo.ReadStored(id)
+func (repo *Repository) ReadStoredBlob(id objectid.ObjectID) (*stored.StoredBlob, error) {
+	s, err := repo.ReadStored(id)
 	if err != nil {
 		return nil, err
 	}
 
-	blob, ok := stored.(*objectstored.StoredBlob)
+	blob, ok := s.(*stored.StoredBlob)
 	if !ok {
-		return nil, fmt.Errorf("repository: expected blob object %s, got %v", id, stored.Object().ObjectType())
+		return nil, fmt.Errorf("repository: expected blob object %s, got %v", id, s.Object().ObjectType())
 	}
 
 	return blob, nil
 }
 
 // ReadStoredTree reads and parses a tree object by ID.
-func (repo *Repository) ReadStoredTree(id objectid.ObjectID) (*objectstored.StoredTree, error) {
-	stored, err := repo.ReadStored(id)
+func (repo *Repository) ReadStoredTree(id objectid.ObjectID) (*stored.StoredTree, error) {
+	s, err := repo.ReadStored(id)
 	if err != nil {
 		return nil, err
 	}
 
-	tree, ok := stored.(*objectstored.StoredTree)
+	tree, ok := s.(*stored.StoredTree)
 	if !ok {
-		return nil, fmt.Errorf("repository: expected tree object %s, got %v", id, stored.Object().ObjectType())
+		return nil, fmt.Errorf("repository: expected tree object %s, got %v", id, s.Object().ObjectType())
 	}
 
 	return tree, nil
 }
 
 // ReadStoredCommit reads and parses a commit object by ID.
-func (repo *Repository) ReadStoredCommit(id objectid.ObjectID) (*objectstored.StoredCommit, error) {
-	stored, err := repo.ReadStored(id)
+func (repo *Repository) ReadStoredCommit(id objectid.ObjectID) (*stored.StoredCommit, error) {
+	s, err := repo.ReadStored(id)
 	if err != nil {
 		return nil, err
 	}
 
-	commit, ok := stored.(*objectstored.StoredCommit)
+	commit, ok := s.(*stored.StoredCommit)
 	if !ok {
-		return nil, fmt.Errorf("repository: expected commit object %s, got %v", id, stored.Object().ObjectType())
+		return nil, fmt.Errorf("repository: expected commit object %s, got %v", id, s.Object().ObjectType())
 	}
 
 	return commit, nil
 }
 
 // ReadStoredTag reads and parses a tag object by ID.
-func (repo *Repository) ReadStoredTag(id objectid.ObjectID) (*objectstored.StoredTag, error) {
-	stored, err := repo.ReadStored(id)
+func (repo *Repository) ReadStoredTag(id objectid.ObjectID) (*stored.StoredTag, error) {
+	s, err := repo.ReadStored(id)
 	if err != nil {
 		return nil, err
 	}
 
-	tag, ok := stored.(*objectstored.StoredTag)
+	tag, ok := s.(*stored.StoredTag)
 	if !ok {
-		return nil, fmt.Errorf("repository: expected tag object %s, got %v", id, stored.Object().ObjectType())
+		return nil, fmt.Errorf("repository: expected tag object %s, got %v", id, s.Object().ObjectType())
 	}
 
 	return tag, nil
diff --git a/repository/tree.go b/repository/tree.go
index d4ef529e..ce3e96e4 100644
--- a/repository/tree.go
+++ b/repository/tree.go
@@ -5,14 +5,14 @@ import (
 	"fmt"
 
 	"codeberg.org/lindenii/furgit/object"
-	"codeberg.org/lindenii/furgit/objectstored"
+	"codeberg.org/lindenii/furgit/object/stored"
 )
 
 // ResolveTreeEntry resolves one path within a stored root tree.
 //
 // parts must contain at least one path segment. Intermediate segments must be
 // tree entries.
-func (repo *Repository) ResolveTreeEntry(tree *objectstored.StoredTree, parts [][]byte) (object.TreeEntry, error) {
+func (repo *Repository) ResolveTreeEntry(tree *stored.StoredTree, parts [][]byte) (object.TreeEntry, error) {
 	if tree == nil {
 		return object.TreeEntry{}, errors.New("repository: nil root tree")
 	}
-- 
cgit v1.3.1-10-gc9f91