*: Remove

33 files changed, 0 insertions, 1201 deletions

diff --git a/object/fetch/doc.go b/object/fetch/doc.go
deleted file mode 100644
index 89bf9a98..00000000
--- a/object/fetch/doc.go
+++ /dev/null
@@ -1,8 +0,0 @@
-// Package fetch loads typed Git objects from object storage and provides
-// higher-level object queries.
-//
-// Fetching is above [objectstore]: it parses stored objects into blobs, trees,
-// commits, and tags, exposes object metadata, peels tree-ish or commit-ish
-// objects, resolves paths within trees, and can expose one tree as an [io/fs]
-// view.
-package fetch
diff --git a/object/fetch/exact_blob.go b/object/fetch/exact_blob.go
deleted file mode 100644
index ef4b84fe..00000000
--- a/object/fetch/exact_blob.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	"codeberg.org/lindenii/furgit/object/blob"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// ExactBlob reads, parses, and wraps the blob at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) ExactBlob(id objectid.ObjectID) (*stored.Stored[*blob.Blob], error) {
-	parsed, err := r.parseObject(id)
-	if err != nil {
-		return nil, err
-	}
-
-	blob, ok := parsed.(*blob.Blob)
-	if !ok {
-		return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeBlob}
-	}
-
-	return stored.New(id, blob), nil
-}
diff --git a/object/fetch/exact_blob_reader.go b/object/fetch/exact_blob_reader.go
deleted file mode 100644
index 4a313d3e..00000000
--- a/object/fetch/exact_blob_reader.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package fetch
-
-import (
-	"io"
-
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// ExactBlobReader returns a reader for the content of the blob at id,
-// together with its content size in bytes.
-//
-// Labels: Life-Parent, Close-Caller.
-func (r *Fetcher) ExactBlobReader(id objectid.ObjectID) (io.ReadCloser, int64, error) {
-	return r.exactReader(id, objecttype.TypeBlob)
-}
diff --git a/object/fetch/exact_commit.go b/object/fetch/exact_commit.go
deleted file mode 100644
index 9483b2b1..00000000
--- a/object/fetch/exact_commit.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	"codeberg.org/lindenii/furgit/object/commit"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// ExactCommit reads, parses, and wraps the commit at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) ExactCommit(id objectid.ObjectID) (*stored.Stored[*commit.Commit], error) {
-	parsed, err := r.parseObject(id)
-	if err != nil {
-		return nil, err
-	}
-
-	commit, ok := parsed.(*commit.Commit)
-	if !ok {
-		return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeCommit}
-	}
-
-	return stored.New(id, commit), nil
-}
diff --git a/object/fetch/exact_object.go b/object/fetch/exact_object.go
deleted file mode 100644
index 2e4a8217..00000000
--- a/object/fetch/exact_object.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package fetch
-
-import (
-	"codeberg.org/lindenii/furgit/object"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-)
-
-// ExactObject reads, parses, and wraps the object at id without constraining
-// its concrete object kind.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) ExactObject(id objectid.ObjectID) (*stored.Stored[object.Object], error) {
-	parsed, err := r.parseObject(id)
-	if err != nil {
-		return nil, err
-	}
-
-	return stored.New(id, parsed), nil
-}
diff --git a/object/fetch/exact_reader.go b/object/fetch/exact_reader.go
deleted file mode 100644
index d588480d..00000000
--- a/object/fetch/exact_reader.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package fetch
-
-import (
-	"io"
-
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// exactReader reads one object's content stream and verifies that its header
-// type matches wantType.
-func (r *Fetcher) exactReader(id objectid.ObjectID, wantType objecttype.Type) (io.ReadCloser, int64, error) {
-	gotType, size, rc, err := r.store.ReadReaderContent(id)
-	if err != nil {
-		return nil, 0, wrapObjectReadError(id, err)
-	}
-
-	if gotType != wantType {
-		_ = rc.Close()
-
-		return nil, 0, &giterrors.ObjectTypeError{OID: id, Got: gotType, Want: wantType}
-	}
-
-	return rc, size, nil
-}
diff --git a/object/fetch/exact_tag.go b/object/fetch/exact_tag.go
deleted file mode 100644
index 230e7d57..00000000
--- a/object/fetch/exact_tag.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	"codeberg.org/lindenii/furgit/object/tag"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// ExactTag reads, parses, and wraps the tag at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) ExactTag(id objectid.ObjectID) (*stored.Stored[*tag.Tag], error) {
-	parsed, err := r.parseObject(id)
-	if err != nil {
-		return nil, err
-	}
-
-	tag, ok := parsed.(*tag.Tag)
-	if !ok {
-		return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeTag}
-	}
-
-	return stored.New(id, tag), nil
-}
diff --git a/object/fetch/exact_tree.go b/object/fetch/exact_tree.go
deleted file mode 100644
index 8bfc87ea..00000000
--- a/object/fetch/exact_tree.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	"codeberg.org/lindenii/furgit/object/tree"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// ExactTree reads, parses, and wraps the tree at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) ExactTree(id objectid.ObjectID) (*stored.Stored[*tree.Tree], error) {
-	parsed, err := r.parseObject(id)
-	if err != nil {
-		return nil, err
-	}
-
-	tree, ok := parsed.(*tree.Tree)
-	if !ok {
-		return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeTree}
-	}
-
-	return stored.New(id, tree), nil
-}
diff --git a/object/fetch/fetcher.go b/object/fetch/fetcher.go
deleted file mode 100644
index fcd64d88..00000000
--- a/object/fetch/fetcher.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package fetch
-
-import objectstore "codeberg.org/lindenii/furgit/object/store"
-
-// Fetcher provides ordinary object access above an object store.
-//
-// It exposes object metadata, typed object loading, tree-ish and commit-ish
-// peeling, path resolution, one-tree fs views, and blob content streaming.
-//
-// Labels: MT-Safe.
-type Fetcher struct {
-	store objectstore.Reader
-}
-
-// New returns a Fetcher that reads objects from store.
-//
-// Labels: Deps-Borrowed, Life-Parent.
-func New(store objectstore.Reader) *Fetcher {
-	return &Fetcher{store: store}
-}
diff --git a/object/fetch/header.go b/object/fetch/header.go
deleted file mode 100644
index 0a535dd9..00000000
--- a/object/fetch/header.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package fetch
-
-import (
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// Header returns the object type and content size at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) Header(id objectid.ObjectID) (objecttype.Type, int64, error) {
-	ty, size, err := r.store.ReadHeader(id)
-	if err != nil {
-		return objecttype.TypeInvalid, 0, wrapObjectReadError(id, err)
-	}
-
-	return ty, size, nil
-}
diff --git a/object/fetch/object_errors.go b/object/fetch/object_errors.go
deleted file mode 100644
index 08de6f75..00000000
--- a/object/fetch/object_errors.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package fetch
-
-import (
-	stderrors "errors"
-
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objectstore "codeberg.org/lindenii/furgit/object/store"
-)
-
-// wrapObjectReadError maps raw object-store lookup failures to fetcher-level
-// object lookup errors.
-func wrapObjectReadError(id objectid.ObjectID, err error) error {
-	if stderrors.Is(err, objectstore.ErrObjectNotFound) {
-		return &giterrors.ObjectMissingError{OID: id}
-	}
-
-	return err
-}
diff --git a/object/fetch/object_parse.go b/object/fetch/object_parse.go
deleted file mode 100644
index 0a61bb3d..00000000
--- a/object/fetch/object_parse.go
+++ /dev/null
@@ -1,27 +0,0 @@
-package fetch
-
-import (
-	"fmt"
-
-	"codeberg.org/lindenii/furgit/object"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-)
-
-func (r *Fetcher) parseObject(id objectid.ObjectID) (object.Object, error) {
-	ty, content, err := r.store.ReadBytesContent(id)
-	if err != nil {
-		return nil, wrapObjectReadError(id, err)
-	}
-
-	parsed, err := object.ParseWithoutHeader(ty, content, id.Algorithm())
-	if err != nil {
-		tyName, ok := ty.Name()
-		if !ok {
-			tyName = fmt.Sprintf("type %d", ty)
-		}
-
-		return nil, fmt.Errorf("object/fetch: parse object %s (%s): %w", id, tyName, err)
-	}
-
-	return parsed, nil
-}
diff --git a/object/fetch/path.go b/object/fetch/path.go
deleted file mode 100644
index e3c468db..00000000
--- a/object/fetch/path.go
+++ /dev/null
@@ -1,105 +0,0 @@
-package fetch
-
-import (
-	"fmt"
-
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-// PathEmptyError indicates that Path received no segments.
-type PathEmptyError struct{}
-
-func (err *PathEmptyError) Error() string {
-	return "object/fetch: empty tree path"
-}
-
-// PathSegmentEmptyError indicates that one path segment is empty.
-type PathSegmentEmptyError struct {
-	Index int
-}
-
-func (err *PathSegmentEmptyError) Error() string {
-	return fmt.Sprintf("object/fetch: empty tree path segment at index %d", err.Index)
-}
-
-// PathNotFoundError indicates that one tree path segment was not found.
-type PathNotFoundError struct {
-	Index int
-	Name  []byte
-}
-
-func (err *PathNotFoundError) Error() string {
-	return fmt.Sprintf("object/fetch: tree entry %q not found at index %d", err.Name, err.Index)
-}
-
-// PathNotTreeError indicates that one intermediate path segment was not a tree.
-type PathNotTreeError struct {
-	Index int
-	Name  []byte
-}
-
-func (err *PathNotTreeError) Error() string {
-	return fmt.Sprintf("object/fetch: path segment %q at index %d is not a tree", err.Name, err.Index)
-}
-
-// Path resolves parts within the tree identified by root and returns the final
-// tree entry.
-//
-// The root object may be any tree-ish object accepted by PeelToTree.
-//
-// parts must contain at least one path segment. Intermediate path segments
-// must resolve to tree entries. The final entry is returned without loading
-// its object. Path segments may not contain \x00.
-//
-// The path cannot be accurately represented as a string or a single []byte
-// because Git tree entry names may include slashes. While []string is
-// technically possible (since Go strings are not necessarily UTF-8), they
-// do often imply UTF-8 in practice, which would be undesirable.
-//
-// If your entry names are valid UTF-8 and uses / solely as segment separators,
-// it may be convenient to use TreeFS for an io/fs.FS-like interface.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) Path(root objectid.ObjectID, parts [][]byte) (tree.TreeEntry, error) {
-	if len(parts) == 0 {
-		return tree.TreeEntry{}, &PathEmptyError{}
-	}
-
-	current, err := r.PeelToTree(root)
-	if err != nil {
-		return tree.TreeEntry{}, err
-	}
-
-	for i, part := range parts {
-		if len(part) == 0 {
-			return tree.TreeEntry{}, &PathSegmentEmptyError{Index: i}
-		}
-
-		entry := current.Object().Entry(part)
-		if entry == nil {
-			return tree.TreeEntry{}, &PathNotFoundError{
-				Index: i,
-				Name:  append([]byte(nil), part...),
-			}
-		}
-
-		if i == len(parts)-1 {
-			return *entry, nil
-		}
-
-		if entry.Mode != tree.FileModeDir {
-			return tree.TreeEntry{}, &PathNotTreeError{
-				Index: i,
-				Name:  append([]byte(nil), part...),
-			}
-		}
-
-		current, err = r.ExactTree(entry.ID)
-		if err != nil {
-			return tree.TreeEntry{}, err
-		}
-	}
-
-	return tree.TreeEntry{}, &PathNotFoundError{Index: len(parts) - 1}
-}
diff --git a/object/fetch/peel_to_blob.go b/object/fetch/peel_to_blob.go
deleted file mode 100644
index adf86495..00000000
--- a/object/fetch/peel_to_blob.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	"codeberg.org/lindenii/furgit/object/blob"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	"codeberg.org/lindenii/furgit/object/tag"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToBlob peels tags until it reaches a blob.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) PeelToBlob(id objectid.ObjectID) (*stored.Stored[*blob.Blob], error) {
-	for {
-		obj, err := r.ExactObject(id)
-		if err != nil {
-			return nil, err
-		}
-
-		switch parsed := obj.Object().(type) {
-		case *blob.Blob:
-			return stored.New(id, parsed), nil
-		case *tag.Tag:
-			id = parsed.Target
-		default:
-			return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeBlob}
-		}
-	}
-}
diff --git a/object/fetch/peel_to_blob_id.go b/object/fetch/peel_to_blob_id.go
deleted file mode 100644
index 7a43b4cc..00000000
--- a/object/fetch/peel_to_blob_id.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToBlobID peels tags until it reaches a blob object ID.
-func (r *Fetcher) PeelToBlobID(id objectid.ObjectID) (objectid.ObjectID, error) {
-	for {
-		ty, _, err := r.Header(id)
-		if err != nil {
-			return objectid.ObjectID{}, err
-		}
-
-		switch ty {
-		case objecttype.TypeBlob:
-			return id, nil
-		case objecttype.TypeTag:
-			tag, err := r.ExactTag(id)
-			if err != nil {
-				return objectid.ObjectID{}, err
-			}
-
-			id = tag.Object().Target
-		case objecttype.TypeInvalid,
-			objecttype.TypeCommit,
-			objecttype.TypeTree,
-			objecttype.TypeFuture,
-			objecttype.TypeOfsDelta,
-			objecttype.TypeRefDelta:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeBlob}
-		default:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeBlob}
-		}
-	}
-}
diff --git a/object/fetch/peel_to_blob_reader.go b/object/fetch/peel_to_blob_reader.go
deleted file mode 100644
index dedffd01..00000000
--- a/object/fetch/peel_to_blob_reader.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package fetch
-
-import (
-	"io"
-
-	objectid "codeberg.org/lindenii/furgit/object/id"
-)
-
-// PeelToBlobReader returns a reader for the content of the peeled blob at id,
-// together with its content size in bytes.
-//
-// Labels: Life-Parent, Close-Caller.
-func (r *Fetcher) PeelToBlobReader(id objectid.ObjectID) (io.ReadCloser, int64, error) {
-	blobID, err := r.PeelToBlobID(id)
-	if err != nil {
-		return nil, 0, err
-	}
-
-	return r.ExactBlobReader(blobID)
-}
diff --git a/object/fetch/peel_to_commit.go b/object/fetch/peel_to_commit.go
deleted file mode 100644
index e5fdce2b..00000000
--- a/object/fetch/peel_to_commit.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	"codeberg.org/lindenii/furgit/object/commit"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	"codeberg.org/lindenii/furgit/object/tag"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToCommit peels tags until it reaches a commit.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) PeelToCommit(id objectid.ObjectID) (*stored.Stored[*commit.Commit], error) {
-	for {
-		obj, err := r.ExactObject(id)
-		if err != nil {
-			return nil, err
-		}
-
-		switch parsed := obj.Object().(type) {
-		case *commit.Commit:
-			return stored.New(id, parsed), nil
-		case *tag.Tag:
-			id = parsed.Target
-		default:
-			return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeCommit}
-		}
-	}
-}
diff --git a/object/fetch/peel_to_commit_id.go b/object/fetch/peel_to_commit_id.go
deleted file mode 100644
index 7b58bdea..00000000
--- a/object/fetch/peel_to_commit_id.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToCommitID peels tags until it reaches a commit object ID.
-func (r *Fetcher) PeelToCommitID(id objectid.ObjectID) (objectid.ObjectID, error) {
-	for {
-		ty, _, err := r.Header(id)
-		if err != nil {
-			return objectid.ObjectID{}, err
-		}
-
-		switch ty {
-		case objecttype.TypeCommit:
-			return id, nil
-		case objecttype.TypeTag:
-			tag, err := r.ExactTag(id)
-			if err != nil {
-				return objectid.ObjectID{}, err
-			}
-
-			id = tag.Object().Target
-		case objecttype.TypeInvalid,
-			objecttype.TypeTree,
-			objecttype.TypeBlob,
-			objecttype.TypeFuture,
-			objecttype.TypeOfsDelta,
-			objecttype.TypeRefDelta:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeCommit}
-		default:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeCommit}
-		}
-	}
-}
diff --git a/object/fetch/peel_to_tree.go b/object/fetch/peel_to_tree.go
deleted file mode 100644
index adc87e6b..00000000
--- a/object/fetch/peel_to_tree.go
+++ /dev/null
@@ -1,35 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	"codeberg.org/lindenii/furgit/object/commit"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/stored"
-	"codeberg.org/lindenii/furgit/object/tag"
-	"codeberg.org/lindenii/furgit/object/tree"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToTree peels tags until it reaches a tree or commit. If it reaches a
-// commit, it returns the commit's root tree.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) PeelToTree(id objectid.ObjectID) (*stored.Stored[*tree.Tree], error) {
-	for {
-		obj, err := r.ExactObject(id)
-		if err != nil {
-			return nil, err
-		}
-
-		switch parsed := obj.Object().(type) {
-		case *tree.Tree:
-			return stored.New(id, parsed), nil
-		case *commit.Commit:
-			return r.ExactTree(parsed.Tree)
-		case *tag.Tag:
-			id = parsed.Target
-		default:
-			return nil, &giterrors.ObjectTypeError{OID: id, Got: parsed.ObjectType(), Want: objecttype.TypeTree}
-		}
-	}
-}
diff --git a/object/fetch/peel_to_tree_id.go b/object/fetch/peel_to_tree_id.go
deleted file mode 100644
index 4c9bdac9..00000000
--- a/object/fetch/peel_to_tree_id.go
+++ /dev/null
@@ -1,45 +0,0 @@
-package fetch
-
-import (
-	giterrors "codeberg.org/lindenii/furgit/errors"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	objecttype "codeberg.org/lindenii/furgit/object/type"
-)
-
-// PeelToTreeID peels tags until it reaches a tree object ID, or a commit whose
-// root tree object ID is then returned.
-func (r *Fetcher) PeelToTreeID(id objectid.ObjectID) (objectid.ObjectID, error) {
-	for {
-		ty, _, err := r.Header(id)
-		if err != nil {
-			return objectid.ObjectID{}, err
-		}
-
-		switch ty {
-		case objecttype.TypeTree:
-			return id, nil
-		case objecttype.TypeCommit:
-			commit, err := r.ExactCommit(id)
-			if err != nil {
-				return objectid.ObjectID{}, err
-			}
-
-			return commit.Object().Tree, nil
-		case objecttype.TypeTag:
-			tag, err := r.ExactTag(id)
-			if err != nil {
-				return objectid.ObjectID{}, err
-			}
-
-			id = tag.Object().Target
-		case objecttype.TypeInvalid,
-			objecttype.TypeBlob,
-			objecttype.TypeFuture,
-			objecttype.TypeOfsDelta,
-			objecttype.TypeRefDelta:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeTree}
-		default:
-			return objectid.ObjectID{}, &giterrors.ObjectTypeError{OID: id, Got: ty, Want: objecttype.TypeTree}
-		}
-	}
-}
diff --git a/object/fetch/size.go b/object/fetch/size.go
deleted file mode 100644
index da59e12a..00000000
--- a/object/fetch/size.go
+++ /dev/null
@@ -1,15 +0,0 @@
-package fetch
-
-import objectid "codeberg.org/lindenii/furgit/object/id"
-
-// Size returns the object content size at id.
-//
-// Labels: Life-Parent.
-func (r *Fetcher) Size(id objectid.ObjectID) (int64, error) {
-	size, err := r.store.ReadSize(id)
-	if err != nil {
-		return 0, wrapObjectReadError(id, err)
-	}
-
-	return size, nil
-}
diff --git a/object/fetch/treefs.go b/object/fetch/treefs.go
deleted file mode 100644
index 39ea7ad5..00000000
--- a/object/fetch/treefs.go
+++ /dev/null
@@ -1,30 +0,0 @@
-package fetch
-
-import (
-	"io/fs"
-
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-// TreeFS exposes one Git tree as an fs.FS view backed by a Fetcher.
-//
-// TreeFS interprets names using io/fs path rules. Those rules do not match raw
-// Git tree entry naming exactly: names are UTF-8, slash-separated, and must be
-// valid fs.FS paths. Tree entries that cannot be represented under those rules
-// are not addressable through this API.
-//
-// Labels: MT-Safe.
-type TreeFS struct {
-	fetcher   *Fetcher
-	rootTree  objectid.ObjectID
-	rootEntry *tree.TreeEntry
-}
-
-var (
-	_ fs.FS         = (*TreeFS)(nil)
-	_ fs.ReadFileFS = (*TreeFS)(nil)
-	_ fs.ReadDirFS  = (*TreeFS)(nil)
-	_ fs.StatFS     = (*TreeFS)(nil)
-	_ fs.SubFS      = (*TreeFS)(nil)
-)
diff --git a/object/fetch/treefs_entry.go b/object/fetch/treefs_entry.go
deleted file mode 100644
index e577d86c..00000000
--- a/object/fetch/treefs_entry.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package fetch
-
-import (
-	"errors"
-	"fmt"
-	"io/fs"
-
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-func (treeFS *TreeFS) resolvePath(op treeFSOp, name string) (treeEntryValue, error) {
-	if !treeFSValidPath(name) {
-		return treeEntryValue{}, treeFSPathError(op, name, fs.ErrInvalid)
-	}
-
-	if name == "." {
-		return treeEntryValue{
-			name:      ".",
-			mode:      tree.FileModeDir,
-			treeID:    treeFS.rootTree,
-			treeEntry: treeFS.rootEntry,
-		}, nil
-	}
-
-	entry, err := treeFS.fetcher.Path(treeFS.rootTree, tree.SplitPath([]byte(name)))
-	if err != nil {
-		return treeEntryValue{}, treeFS.pathResolveError(op, name, err)
-	}
-
-	return treeEntryValue{
-		name:      string(entry.Name),
-		mode:      entry.Mode,
-		objectID:  entry.ID,
-		treeEntry: &entry,
-	}, nil
-}
-
-func (treeFS *TreeFS) pathResolveError(op treeFSOp, name string, err error) error {
-	if _, ok := errors.AsType[*PathNotFoundError](err); ok {
-		return treeFSPathError(op, name, fs.ErrNotExist)
-	}
-
-	if _, ok := errors.AsType[*PathNotTreeError](err); ok {
-		return treeFSPathError(op, name, fs.ErrInvalid)
-	}
-
-	if _, ok := errors.AsType[*PathEmptyError](err); ok {
-		return treeFSPathError(op, name, fs.ErrInvalid)
-	}
-
-	if _, ok := errors.AsType[*PathSegmentEmptyError](err); ok {
-		return treeFSPathError(op, name, fs.ErrInvalid)
-	}
-
-	return treeFSPathError(op, name, err)
-}
-
-type treeEntryValue struct {
-	name      string
-	mode      tree.FileMode
-	objectID  objectid.ObjectID
-	treeID    objectid.ObjectID
-	treeEntry *tree.TreeEntry
-}
-
-func (entry treeEntryValue) isDir() bool {
-	return entry.mode == tree.FileModeDir
-}
-
-func (entry treeEntryValue) blobSize(fetcher *Fetcher) (int64, error) {
-	return fetcher.Size(entry.objectID)
-}
-
-func (entry treeEntryValue) subtreeID() (objectid.ObjectID, error) {
-	if entry.name == "." {
-		return entry.treeID, nil
-	}
-
-	if entry.mode != tree.FileModeDir {
-		return objectid.ObjectID{}, fmt.Errorf("object/fetch: path %q is not a tree", entry.name)
-	}
-
-	return entry.objectID, nil
-}
diff --git a/object/fetch/treefs_info.go b/object/fetch/treefs_info.go
deleted file mode 100644
index f1db7e9a..00000000
--- a/object/fetch/treefs_info.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package fetch
-
-import (
-	"io/fs"
-	"time"
-
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-type treeFSInfo struct {
-	name  string
-	mode  fs.FileMode
-	size  int64
-	sys   any
-	isDir bool
-}
-
-var (
-	_ fs.FileInfo = (*treeFSInfo)(nil)
-	_ fs.DirEntry = (*treeFSInfo)(nil)
-)
-
-func (info *treeFSInfo) Name() string       { return info.name }
-func (info *treeFSInfo) Size() int64        { return info.size }
-func (info *treeFSInfo) Mode() fs.FileMode  { return info.mode }
-func (info *treeFSInfo) Type() fs.FileMode  { return info.mode.Type() }
-func (info *treeFSInfo) IsDir() bool        { return info.isDir }
-func (info *treeFSInfo) ModTime() time.Time { return time.Time{} }
-func (info *treeFSInfo) Sys() any           { return info.sys }
-func (info *treeFSInfo) Info() (fs.FileInfo, error) {
-	return info, nil
-}
-
-func treeFSEntryMode(mode tree.FileMode) fs.FileMode {
-	switch mode {
-	case tree.FileModeDir:
-		return fs.ModeDir | 0o555
-	case tree.FileModeRegular:
-		return 0o444
-	case tree.FileModeExecutable:
-		return 0o555
-	case tree.FileModeSymlink:
-		return fs.ModeSymlink | 0o444
-	case tree.FileModeGitlink:
-		return fs.ModeIrregular
-	default:
-		return fs.ModeIrregular
-	}
-}
-
-func (treeFS *TreeFS) statEntry(entry treeEntryValue) (*treeFSInfo, error) {
-	size := int64(0)
-
-	if entry.mode == tree.FileModeRegular || entry.mode == tree.FileModeExecutable || entry.mode == tree.FileModeSymlink {
-		var err error
-
-		size, err = entry.blobSize(treeFS.fetcher)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	var sys any
-	if entry.treeEntry != nil {
-		sys = *entry.treeEntry
-	}
-
-	return &treeFSInfo{
-		name:  entry.name,
-		mode:  treeFSEntryMode(entry.mode),
-		size:  size,
-		sys:   sys,
-		isDir: entry.isDir(),
-	}, nil
-}
diff --git a/object/fetch/treefs_new.go b/object/fetch/treefs_new.go
deleted file mode 100644
index f1096a3c..00000000
--- a/object/fetch/treefs_new.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package fetch
-
-import objectid "codeberg.org/lindenii/furgit/object/id"
-
-// TreeFS returns a new filesystem view rooted at root, which may be any
-// tree-ish object accepted by PeelToTreeID.
-//
-// Labels: Deps-Borrowed, Life-Parent.
-func (r *Fetcher) TreeFS(root objectid.ObjectID) (*TreeFS, error) {
-	rootTree, err := r.PeelToTreeID(root)
-	if err != nil {
-		return nil, err
-	}
-
-	return &TreeFS{
-		fetcher:  r,
-		rootTree: rootTree,
-	}, nil
-}
diff --git a/object/fetch/treefs_op.go b/object/fetch/treefs_op.go
deleted file mode 100644
index f0472923..00000000
--- a/object/fetch/treefs_op.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package fetch
-
-type treeFSOp uint8
-
-const (
-	treeFSOpOpen treeFSOp = iota
-	treeFSOpReadFile
-	treeFSOpReadDir
-	treeFSOpStat
-	treeFSOpSub
-)
-
-func (op treeFSOp) pathErrorOp() string {
-	switch op {
-	case treeFSOpOpen:
-		return "open"
-	case treeFSOpReadFile:
-		return "readfile"
-	case treeFSOpReadDir:
-		return "readdir"
-	case treeFSOpStat:
-		return "stat"
-	case treeFSOpSub:
-		return "sub"
-	default:
-		return "treefs"
-	}
-}
diff --git a/object/fetch/treefs_open.go b/object/fetch/treefs_open.go
deleted file mode 100644
index fc0f7635..00000000
--- a/object/fetch/treefs_open.go
+++ /dev/null
@@ -1,122 +0,0 @@
-package fetch
-
-import (
-	"fmt"
-	"io"
-	"io/fs"
-
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-// Open opens name for reading.
-//
-// Directories are returned as fs.ReadDirFile values. Gitlink entries are not
-// readable through TreeFS.
-func (treeFS *TreeFS) Open(name string) (fs.File, error) {
-	entry, err := treeFS.resolvePath(treeFSOpOpen, name)
-	if err != nil {
-		return nil, err
-	}
-
-	info, err := treeFS.statEntry(entry)
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpOpen, name, err)
-	}
-
-	if entry.isDir() {
-		treeID, err := entry.subtreeID()
-		if err != nil {
-			return nil, treeFSPathError(treeFSOpOpen, name, err)
-		}
-
-		tree, err := treeFS.fetcher.ExactTree(treeID)
-		if err != nil {
-			return nil, treeFSPathError(treeFSOpOpen, name, err)
-		}
-
-		entries := make([]fs.DirEntry, 0, len(tree.Object().Entries))
-		for _, child := range tree.Object().Entries {
-			childEntry := treeEntryValue{
-				name:      string(child.Name),
-				mode:      child.Mode,
-				objectID:  child.ID,
-				treeEntry: &child,
-			}
-
-			childInfo, err := treeFS.statEntry(childEntry)
-			if err != nil {
-				return nil, treeFSPathError(treeFSOpOpen, name, err)
-			}
-
-			entries = append(entries, childInfo)
-		}
-
-		return &treeFSDir{
-			info:    info,
-			entries: entries,
-		}, nil
-	}
-
-	if entry.mode == tree.FileModeGitlink {
-		return nil, treeFSPathError(treeFSOpOpen, name, fmt.Errorf("object/fetch: gitlink entries are not readable as files"))
-	}
-
-	reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpOpen, name, err)
-	}
-
-	return &treeFSBlob{
-		info:   info,
-		reader: reader,
-	}, nil
-}
-
-type treeFSBlob struct {
-	info   *treeFSInfo
-	reader io.ReadCloser
-}
-
-var _ fs.File = (*treeFSBlob)(nil)
-
-func (file *treeFSBlob) Stat() (fs.FileInfo, error) { return file.info, nil }
-func (file *treeFSBlob) Read(p []byte) (int, error) { return file.reader.Read(p) }
-func (file *treeFSBlob) Close() error               { return file.reader.Close() }
-
-type treeFSDir struct {
-	info    *treeFSInfo
-	entries []fs.DirEntry
-	offset  int
-}
-
-var (
-	_ fs.File        = (*treeFSDir)(nil)
-	_ fs.ReadDirFile = (*treeFSDir)(nil)
-)
-
-func (dir *treeFSDir) Stat() (fs.FileInfo, error) { return dir.info, nil }
-func (dir *treeFSDir) Close() error               { return nil }
-
-func (dir *treeFSDir) Read(_ []byte) (int, error) {
-	return 0, fs.ErrInvalid
-}
-
-func (dir *treeFSDir) ReadDir(n int) ([]fs.DirEntry, error) {
-	if dir.offset >= len(dir.entries) && n > 0 {
-		return nil, io.EOF
-	}
-
-	if n <= 0 {
-		out := append([]fs.DirEntry(nil), dir.entries[dir.offset:]...)
-		dir.offset = len(dir.entries)
-
-		return out, nil
-	}
-
-	end := min(dir.offset+n, len(dir.entries))
-
-	out := append([]fs.DirEntry(nil), dir.entries[dir.offset:end]...)
-	dir.offset = end
-
-	return out, nil
-}
diff --git a/object/fetch/treefs_path.go b/object/fetch/treefs_path.go
deleted file mode 100644
index a2dc3155..00000000
--- a/object/fetch/treefs_path.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package fetch
-
-import "io/fs"
-
-func treeFSValidPath(name string) bool {
-	return name == "." || fs.ValidPath(name)
-}
-
-func treeFSPathError(op treeFSOp, path string, err error) error {
-	return &fs.PathError{Op: op.pathErrorOp(), Path: path, Err: err}
-}
diff --git a/object/fetch/treefs_readdir.go b/object/fetch/treefs_readdir.go
deleted file mode 100644
index 7518c607..00000000
--- a/object/fetch/treefs_readdir.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package fetch
-
-import "io/fs"
-
-// ReadDir reads and returns all directory entries for name.
-func (treeFS *TreeFS) ReadDir(name string) ([]fs.DirEntry, error) {
-	file, err := treeFS.Open(name)
-	if err != nil {
-		return nil, err
-	}
-
-	defer func() { _ = file.Close() }()
-
-	readDirFile, ok := file.(fs.ReadDirFile)
-	if !ok {
-		return nil, treeFSPathError(treeFSOpReadDir, name, fs.ErrInvalid)
-	}
-
-	return readDirFile.ReadDir(-1)
-}
diff --git a/object/fetch/treefs_readfile.go b/object/fetch/treefs_readfile.go
deleted file mode 100644
index b248135f..00000000
--- a/object/fetch/treefs_readfile.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package fetch
-
-import (
-	"fmt"
-	"io"
-
-	"codeberg.org/lindenii/furgit/object/tree"
-)
-
-// ReadFile reads the blob contents at name.
-//
-// Directories and gitlink entries are not readable through TreeFS.
-func (treeFS *TreeFS) ReadFile(name string) ([]byte, error) {
-	entry, err := treeFS.resolvePath(treeFSOpReadFile, name)
-	if err != nil {
-		return nil, err
-	}
-
-	if entry.isDir() {
-		return nil, treeFSPathError(treeFSOpReadFile, name, fmt.Errorf("is a directory"))
-	}
-
-	if entry.mode == tree.FileModeGitlink {
-		return nil, treeFSPathError(treeFSOpReadFile, name, fmt.Errorf("object/fetch: gitlink entries are not readable as files"))
-	}
-
-	reader, _, err := treeFS.fetcher.ExactBlobReader(entry.objectID)
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpReadFile, name, err)
-	}
-
-	defer func() { _ = reader.Close() }()
-
-	data, err := io.ReadAll(reader)
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpReadFile, name, err)
-	}
-
-	return data, nil
-}
diff --git a/object/fetch/treefs_stat.go b/object/fetch/treefs_stat.go
deleted file mode 100644
index 7d7a6418..00000000
--- a/object/fetch/treefs_stat.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package fetch
-
-import "io/fs"
-
-// Stat returns synthetic file metadata for name.
-//
-// TreeFS metadata reflects Git tree entry mode and blob size where applicable.
-// It does not represent filesystem stat metadata: ModTime is zero, ownership is
-// unavailable, and Sys returns the underlying tree.TreeEntry when one exists.
-func (treeFS *TreeFS) Stat(name string) (fs.FileInfo, error) {
-	entry, err := treeFS.resolvePath(treeFSOpStat, name)
-	if err != nil {
-		return nil, err
-	}
-
-	info, err := treeFS.statEntry(entry)
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpStat, name, err)
-	}
-
-	return info, nil
-}
diff --git a/object/fetch/treefs_sub.go b/object/fetch/treefs_sub.go
deleted file mode 100644
index c303d16d..00000000
--- a/object/fetch/treefs_sub.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package fetch
-
-import "io/fs"
-
-// Sub returns a new TreeFS rooted at dir.
-func (treeFS *TreeFS) Sub(dir string) (fs.FS, error) {
-	entry, err := treeFS.resolvePath(treeFSOpSub, dir)
-	if err != nil {
-		return nil, err
-	}
-
-	treeID, err := entry.subtreeID()
-	if err != nil {
-		return nil, treeFSPathError(treeFSOpSub, dir, fs.ErrInvalid)
-	}
-
-	return &TreeFS{
-		fetcher:   treeFS.fetcher,
-		rootTree:  treeID,
-		rootEntry: entry.treeEntry,
-	}, nil
-}
diff --git a/object/fetch/treefs_test.go b/object/fetch/treefs_test.go
deleted file mode 100644
index ba5d4127..00000000
--- a/object/fetch/treefs_test.go
+++ /dev/null
@@ -1,111 +0,0 @@
-package fetch_test
-
-import (
-	"errors"
-	"io/fs"
-	"testing"
-
-	"codeberg.org/lindenii/furgit/internal/testgit"
-	"codeberg.org/lindenii/furgit/object/fetch"
-	objectid "codeberg.org/lindenii/furgit/object/id"
-	"codeberg.org/lindenii/furgit/object/tree"
-	"codeberg.org/lindenii/furgit/repository"
-)
-
-func TestTreeFS(t *testing.T) {
-	t.Parallel()
-
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		t.Parallel()
-
-		repoData := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo})
-		repoData.WriteFile(t, "plain.txt", []byte("plain\n"), 0o644)
-		repoData.WriteFileAll(t, "dir/exec.sh", []byte("#!/bin/sh\nexit 0\n"), 0o755, 0o755)
-		repoData.SymbolicRef(t, "HEAD", "refs/heads/main")
-		_ = repoData.Run(t, "add", ".")
-		treeHex := repoData.Run(t, "write-tree")
-
-		treeID, err := objectid.ParseHex(algo, treeHex)
-		if err != nil {
-			t.Fatalf("ParseHex(write-tree): %v", err)
-		}
-
-		commitID := repoData.CommitTree(t, treeID, "treefs")
-
-		root := repoData.OpenGitRoot(t)
-
-		repo, err := repository.Open(root)
-		if err != nil {
-			t.Fatalf("repository.Open: %v", err)
-		}
-
-		defer func() { _ = repo.Close() }()
-
-		fetcher := fetch.New(repo.Objects())
-
-		treeFS, err := fetcher.TreeFS(commitID)
-		if err != nil {
-			t.Fatalf("fetcher.TreeFS: %v", err)
-		}
-
-		content, err := treeFS.ReadFile("plain.txt")
-		if err != nil {
-			t.Fatalf("ReadFile(plain.txt): %v", err)
-		}
-
-		if string(content) != "plain\n" {
-			t.Fatalf("ReadFile(plain.txt) = %q, want %q", string(content), "plain\n")
-		}
-
-		entries, err := treeFS.ReadDir(".")
-		if err != nil {
-			t.Fatalf("ReadDir(.): %v", err)
-		}
-
-		if len(entries) != 2 {
-			t.Fatalf("len(ReadDir(.)) = %d, want 2", len(entries))
-		}
-
-		info, err := treeFS.Stat("plain.txt")
-		if err != nil {
-			t.Fatalf("Stat(plain.txt): %v", err)
-		}
-
-		entry, ok := info.Sys().(tree.TreeEntry)
-		if !ok {
-			t.Fatalf("Stat(plain.txt).Sys() type = %T, want tree.TreeEntry", info.Sys())
-		}
-
-		if entry.Mode != tree.FileModeRegular {
-			t.Fatalf("Stat(plain.txt).Sys().Mode = %o, want %o", entry.Mode, tree.FileModeRegular)
-		}
-
-		subFS, err := treeFS.Sub("dir")
-		if err != nil {
-			t.Fatalf("Sub(dir): %v", err)
-		}
-
-		subReadFileFS, ok := subFS.(fs.ReadFileFS)
-		if !ok {
-			t.Fatalf("Sub(dir) type does not implement fs.ReadFileFS")
-		}
-
-		subContent, err := subReadFileFS.ReadFile("exec.sh")
-		if err != nil {
-			t.Fatalf("Sub(dir).ReadFile(exec.sh): %v", err)
-		}
-
-		if string(subContent) != "#!/bin/sh\nexit 0\n" {
-			t.Fatalf("Sub(dir).ReadFile(exec.sh) = %q", string(subContent))
-		}
-
-		_, err = treeFS.ReadFile("dir")
-		if err == nil {
-			t.Fatal("ReadFile(dir) unexpectedly succeeded")
-		}
-
-		if _, ok := errors.AsType[*fs.PathError](err); !ok {
-			t.Fatalf("ReadFile(dir) err type = %T, want *fs.PathError", err)
-		}
-	})
-}