9 files changed, 0 insertions, 551 deletions
diff --git a/refstore/packed/TODO b/refstore/packed/TODO
deleted file mode 100644
index 470648bb..00000000
--- a/refstore/packed/TODO
+++ /dev/null
@@ -1 +0,0 @@
-Make ref name and parse-line validations stricter.
diff --git a/refstore/packed/close.go b/refstore/packed/close.go
deleted file mode 100644
index 28c797cd..00000000
--- a/refstore/packed/close.go
+++ /dev/null
@@ -1,6 +0,0 @@
-package packed
-
-// Close releases resources associated with the backend.
-func (store *Store) Close() error {
-	return nil
-}
diff --git a/refstore/packed/list.go b/refstore/packed/list.go
deleted file mode 100644
index 422c1026..00000000
--- a/refstore/packed/list.go
+++ /dev/null
@@ -1,39 +0,0 @@
-package packed
-
-import (
-	"path"
-
-	"codeberg.org/lindenii/furgit/ref"
-)
-
-// List lists packed references matching pattern.
-//
-// Pattern uses path.Match syntax against full reference names.
-// Empty pattern matches all references.
-func (store *Store) List(pattern string) ([]ref.Ref, error) {
-	matchAll := pattern == ""
-	if !matchAll {
-		_, err := path.Match(pattern, "refs/heads/main")
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	refs := make([]ref.Ref, 0, len(store.ordered))
-	for _, entry := range store.ordered {
-		if !matchAll {
-			matched, err := path.Match(pattern, entry.Name())
-			if err != nil {
-				return nil, err
-			}
-
-			if !matched {
-				continue
-			}
-		}
-
-		refs = append(refs, entry)
-	}
-
-	return refs, nil
-}
diff --git a/refstore/packed/new.go b/refstore/packed/new.go
deleted file mode 100644
index 890d42ed..00000000
--- a/refstore/packed/new.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package packed
-
-import (
-	"fmt"
-	"os"
-
-	"codeberg.org/lindenii/furgit/objectid"
-)
-
-// New parses packed-refs from one repository root using the given object ID
-// algorithm.
-func New(root *os.Root, algo objectid.Algorithm) (*Store, error) {
-	if algo.Size() == 0 {
-		return nil, objectid.ErrInvalidAlgorithm
-	}
-
-	packedRefs, err := root.Open("packed-refs")
-	if err != nil {
-		return nil, fmt.Errorf("refstore/packed: open packed-refs: %w", err)
-	}
-
-	defer func() { _ = packedRefs.Close() }()
-
-	byName, ordered, err := parsePackedRefs(packedRefs, algo)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Store{
-		byName:  byName,
-		ordered: ordered,
-	}, nil
-}
diff --git a/refstore/packed/packed_test.go b/refstore/packed/packed_test.go
deleted file mode 100644
index e5a56dda..00000000
--- a/refstore/packed/packed_test.go
+++ /dev/null
@@ -1,299 +0,0 @@
-package packed_test
-
-import (
-	"bytes"
-	"errors"
-	"os"
-	"slices"
-	"testing"
-
-	"codeberg.org/lindenii/furgit/internal/testgit"
-	"codeberg.org/lindenii/furgit/objectid"
-	"codeberg.org/lindenii/furgit/ref"
-	"codeberg.org/lindenii/furgit/refstore"
-	"codeberg.org/lindenii/furgit/refstore/packed"
-)
-
-func openPackedRefStoreFromRepo(t *testing.T, testRepo *testgit.TestRepo, algo objectid.Algorithm) *packed.Store {
-	t.Helper()
-
-	root := testRepo.OpenGitRoot(t)
-
-	store, err := packed.New(root, algo)
-	if err != nil {
-		t.Fatalf("packed.New: %v", err)
-	}
-
-	return store
-}
-
-func openPackedRefStoreFromContent(t *testing.T, content string, algo objectid.Algorithm) (*packed.Store, error) {
-	t.Helper()
-
-	dir := t.TempDir()
-
-	root, err := os.OpenRoot(dir)
-	if err != nil {
-		t.Fatalf("OpenRoot(temp): %v", err)
-	}
-
-	defer func() { _ = root.Close() }()
-
-	err = root.WriteFile("packed-refs", []byte(content), 0o644)
-	if err != nil {
-		t.Fatalf("WriteFile(packed-refs): %v", err)
-	}
-
-	return packed.New(root, algo)
-}
-
-func TestPackedResolveAndPeeled(t *testing.T) {
-	t.Parallel()
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
-		_, _, commitID := testRepo.MakeCommit(t, "packed refs commit")
-		testRepo.UpdateRef(t, "refs/heads/main", commitID)
-		tagID := testRepo.TagAnnotated(t, "v1.0.0", commitID, "annotated tag")
-		testRepo.PackRefs(t, "--all", "--prune")
-
-		store := openPackedRefStoreFromRepo(t, testRepo, algo)
-
-		resolvedMain, err := store.Resolve("refs/heads/main")
-		if err != nil {
-			t.Fatalf("Resolve(main): %v", err)
-		}
-
-		mainDet, ok := resolvedMain.(ref.Detached)
-		if !ok {
-			t.Fatalf("Resolve(main) type = %T, want ref.Detached", resolvedMain)
-		}
-
-		if mainDet.ID != commitID {
-			t.Fatalf("Resolve(main) id = %s, want %s", mainDet.ID, commitID)
-		}
-
-		resolvedTag, err := store.Resolve("refs/tags/v1.0.0")
-		if err != nil {
-			t.Fatalf("Resolve(tag): %v", err)
-		}
-
-		tagDet, ok := resolvedTag.(ref.Detached)
-		if !ok {
-			t.Fatalf("Resolve(tag) type = %T, want ref.Detached", resolvedTag)
-		}
-
-		if tagDet.ID != tagID {
-			t.Fatalf("Resolve(tag) id = %s, want %s", tagDet.ID, tagID)
-		}
-
-		if tagDet.Peeled == nil {
-			t.Fatalf("Resolve(tag) peeled = nil, want commit")
-		}
-
-		if *tagDet.Peeled != commitID {
-			t.Fatalf("Resolve(tag) peeled = %s, want %s", *tagDet.Peeled, commitID)
-		}
-
-		fullTag, err := store.ResolveFully("refs/tags/v1.0.0")
-		if err != nil {
-			t.Fatalf("ResolveFully(tag): %v", err)
-		}
-
-		if fullTag.ID != tagDet.ID {
-			t.Fatalf("ResolveFully(tag) id = %s, want %s", fullTag.ID, tagDet.ID)
-		}
-
-		_, err = store.Resolve("refs/heads/does-not-exist")
-		if !errors.Is(err, refstore.ErrReferenceNotFound) {
-			t.Fatalf("Resolve(not-found) error = %v", err)
-		}
-	})
-}
-
-func TestPackedListAndShorten(t *testing.T) {
-	t.Parallel()
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
-		_, _, commitID := testRepo.MakeCommit(t, "packed refs list commit")
-		testRepo.UpdateRef(t, "refs/heads/main", commitID)
-		testRepo.UpdateRef(t, "refs/tags/main", commitID)
-		testRepo.UpdateRef(t, "refs/remotes/origin/main", commitID)
-		testRepo.PackRefs(t, "--all", "--prune")
-
-		store := openPackedRefStoreFromRepo(t, testRepo, algo)
-
-		all, err := store.List("")
-		if err != nil {
-			t.Fatalf("List(all): %v", err)
-		}
-
-		allNames := make([]string, 0, len(all))
-		for _, entry := range all {
-			allNames = append(allNames, entry.Name())
-		}
-
-		slices.Sort(allNames)
-
-		wantAll := []string{"refs/heads/main", "refs/remotes/origin/main", "refs/tags/main"}
-		if !slices.Equal(allNames, wantAll) {
-			t.Fatalf("List(all) names = %v, want %v", allNames, wantAll)
-		}
-
-		filtered, err := store.List("refs/heads/*")
-		if err != nil {
-			t.Fatalf("List(pattern): %v", err)
-		}
-
-		if len(filtered) != 1 || filtered[0].Name() != "refs/heads/main" {
-			t.Fatalf("List(refs/heads/*) = %v, want refs/heads/main only", filtered)
-		}
-
-		short, err := store.Shorten("refs/heads/main")
-		if err != nil {
-			t.Fatalf("Shorten(main): %v", err)
-		}
-
-		if short != "heads/main" {
-			t.Fatalf("Shorten(main) = %q, want %q", short, "heads/main")
-		}
-
-		_, err = store.Shorten("refs/heads/does-not-exist")
-		if !errors.Is(err, refstore.ErrReferenceNotFound) {
-			t.Fatalf("Shorten(not-found) error = %v", err)
-		}
-	})
-}
-
-func TestPackedListPatternMatrix(t *testing.T) {
-	t.Parallel()
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		testRepo := testgit.NewRepo(t, testgit.RepoOptions{ObjectFormat: algo, Bare: true})
-		_, _, commitID := testRepo.MakeCommit(t, "packed refs pattern matrix")
-		testRepo.UpdateRef(t, "refs/heads/main", commitID)
-		testRepo.UpdateRef(t, "refs/heads/feature/one", commitID)
-		testRepo.UpdateRef(t, "refs/notes/review", commitID)
-		testRepo.UpdateRef(t, "refs/tags/v1", commitID)
-		testRepo.PackRefs(t, "--all", "--prune")
-
-		store := openPackedRefStoreFromRepo(t, testRepo, algo)
-
-		tests := []struct {
-			pattern string
-			want    []string
-		}{
-			{
-				pattern: "refs/heads/*",
-				want:    []string{"refs/heads/main"},
-			},
-			{
-				pattern: "refs/heads/*/*",
-				want:    []string{"refs/heads/feature/one"},
-			},
-			{
-				pattern: "refs/*/feature/one",
-				want:    []string{"refs/heads/feature/one"},
-			},
-			{
-				pattern: "refs/heads/feat?re/one",
-				want:    []string{"refs/heads/feature/one"},
-			},
-			{
-				pattern: "refs/tags/v[0-9]",
-				want:    []string{"refs/tags/v1"},
-			},
-			{
-				pattern: "refs/*/*",
-				want:    []string{"refs/heads/main", "refs/notes/review", "refs/tags/v1"},
-			},
-		}
-
-		for _, tt := range tests {
-			t.Run(tt.pattern, func(t *testing.T) {
-				got, err := store.List(tt.pattern)
-				if err != nil {
-					t.Fatalf("List(%q): %v", tt.pattern, err)
-				}
-
-				gotNames := refNames(got)
-				slices.Sort(gotNames)
-
-				wantNames := append([]string(nil), tt.want...)
-				slices.Sort(wantNames)
-
-				if !slices.Equal(gotNames, wantNames) {
-					t.Fatalf("List(%q) names = %v, want %v", tt.pattern, gotNames, wantNames)
-				}
-			})
-		}
-	})
-}
-
-func TestPackedParseErrors(t *testing.T) {
-	t.Parallel()
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		cases := []struct {
-			name string
-			data string
-		}{
-			{
-				name: "peeled without ref",
-				data: "^" + stringsOfLen("0", algo.HexLen()) + "\n",
-			},
-			{
-				name: "invalid entry",
-				data: "not-a-valid-line\n",
-			},
-			{
-				name: "duplicate ref",
-				data: stringsOfLen("0", algo.HexLen()) + " refs/heads/main\n" +
-					stringsOfLen("1", algo.HexLen()) + " refs/heads/main\n",
-			},
-		}
-
-		for _, tt := range cases {
-			t.Run(tt.name, func(t *testing.T) {
-				_, err := openPackedRefStoreFromContent(t, tt.data, algo)
-				if err == nil {
-					t.Fatalf("packed.New expected parse error")
-				}
-			})
-		}
-	})
-}
-
-func TestPackedNewValidation(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-
-	root, err := os.OpenRoot(dir)
-	if err != nil {
-		t.Fatalf("OpenRoot(temp): %v", err)
-	}
-
-	defer func() { _ = root.Close() }()
-
-	_, err = packed.New(root, objectid.AlgorithmUnknown)
-	if !errors.Is(err, objectid.ErrInvalidAlgorithm) {
-		t.Fatalf("packed.New invalid algorithm error = %v", err)
-	}
-
-	testgit.ForEachAlgorithm(t, func(t *testing.T, algo objectid.Algorithm) { //nolint:thelper
-		_, err = packed.New(root, algo)
-		if !errors.Is(err, os.ErrNotExist) {
-			t.Fatalf("packed.New missing packed-refs error = %v", err)
-		}
-	})
-}
-
-func refNames(refs []ref.Ref) []string {
-	names := make([]string, 0, len(refs))
-	for _, entry := range refs {
-		names = append(names, entry.Name())
-	}
-
-	return names
-}
-
-func stringsOfLen(ch string, n int) string {
-	return string(bytes.Repeat([]byte(ch), n))
-}
diff --git a/refstore/packed/parse.go b/refstore/packed/parse.go
deleted file mode 100644
index 4846d258..00000000
--- a/refstore/packed/parse.go
+++ /dev/null
@@ -1,112 +0,0 @@
-package packed
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"strings"
-
-	"codeberg.org/lindenii/furgit/objectid"
-	"codeberg.org/lindenii/furgit/ref"
-)
-
-// parsePackedRefs parses packed-refs content into detached refs.
-func parsePackedRefs(r io.Reader, algo objectid.Algorithm) (map[string]ref.Detached, []ref.Detached, error) {
-	byName := make(map[string]ref.Detached)
-	ordered := make([]ref.Detached, 0, 32)
-
-	br := bufio.NewReader(r)
-	prev := -1
-	lineNum := 0
-
-	for {
-		line, err := br.ReadString('\n')
-		if err != nil && err != io.EOF {
-			return nil, nil, err
-		}
-
-		if line == "" && err == io.EOF {
-			break
-		}
-
-		lineNum++
-
-		line = strings.TrimSuffix(line, "\n")
-		line = strings.TrimSuffix(line, "\r")
-
-		line = strings.TrimSpace(line)
-		if line == "" {
-			if err == io.EOF {
-				break
-			}
-
-			continue
-		}
-
-		if strings.HasPrefix(line, "#") {
-			if err == io.EOF {
-				break
-			}
-
-			continue
-		}
-
-		if strings.HasPrefix(line, "^") {
-			if prev < 0 {
-				return nil, nil, fmt.Errorf("refstore/packed: line %d: peeled line without preceding ref", lineNum)
-			}
-
-			peeledHex := strings.TrimSpace(strings.TrimPrefix(line, "^"))
-
-			peeled, parseErr := objectid.ParseHex(algo, peeledHex)
-			if parseErr != nil {
-				return nil, nil, fmt.Errorf("refstore/packed: line %d: invalid peeled oid: %w", lineNum, parseErr)
-			}
-
-			peeledCopy := peeled
-			cur := ordered[prev]
-			cur.Peeled = &peeledCopy
-			ordered[prev] = cur
-			byName[cur.Name()] = cur
-
-			if err == io.EOF {
-				break
-			}
-
-			continue
-		}
-
-		fields := strings.Fields(line)
-		if len(fields) != 2 {
-			return nil, nil, fmt.Errorf("refstore/packed: line %d: malformed entry", lineNum)
-		}
-
-		id, parseErr := objectid.ParseHex(algo, fields[0])
-		if parseErr != nil {
-			return nil, nil, fmt.Errorf("refstore/packed: line %d: invalid oid: %w", lineNum, parseErr)
-		}
-
-		name := fields[1]
-		if name == "" {
-			return nil, nil, fmt.Errorf("refstore/packed: line %d: empty ref name", lineNum)
-		}
-
-		if _, exists := byName[name]; exists {
-			return nil, nil, fmt.Errorf("refstore/packed: line %d: duplicate ref %q", lineNum, name)
-		}
-
-		detached := ref.Detached{
-			RefName: name,
-			ID:      id,
-		}
-		ordered = append(ordered, detached)
-		prev = len(ordered) - 1
-		byName[name] = detached
-
-		if err == io.EOF {
-			break
-		}
-	}
-
-	return byName, ordered, nil
-}
diff --git a/refstore/packed/resolve.go b/refstore/packed/resolve.go
deleted file mode 100644
index 527b8904..00000000
--- a/refstore/packed/resolve.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package packed
-
-import (
-	"codeberg.org/lindenii/furgit/ref"
-	"codeberg.org/lindenii/furgit/refstore"
-)
-
-// Resolve resolves a packed reference name to a detached ref.
-func (store *Store) Resolve(name string) (ref.Ref, error) { //nolint:ireturn
-	detached, ok := store.byName[name]
-	if !ok {
-		return nil, refstore.ErrReferenceNotFound
-	}
-
-	return detached, nil
-}
-
-// ResolveFully resolves a packed reference name to a detached ref.
-//
-// Packed refs are detached-only, so ResolveFully is equivalent to Resolve.
-func (store *Store) ResolveFully(name string) (ref.Detached, error) {
-	detached, ok := store.byName[name]
-	if !ok {
-		return ref.Detached{}, refstore.ErrReferenceNotFound
-	}
-
-	return detached, nil
-}
diff --git a/refstore/packed/shorten.go b/refstore/packed/shorten.go
deleted file mode 100644
index 493b5422..00000000
--- a/refstore/packed/shorten.go
+++ /dev/null
@@ -1,18 +0,0 @@
-package packed
-
-import "codeberg.org/lindenii/furgit/refstore"
-
-// Shorten returns the shortest unambiguous shorthand for a packed ref name.
-func (store *Store) Shorten(name string) (string, error) {
-	_, ok := store.byName[name]
-	if !ok {
-		return "", refstore.ErrReferenceNotFound
-	}
-
-	names := make([]string, 0, len(store.ordered))
-	for _, entry := range store.ordered {
-		names = append(names, entry.Name())
-	}
-
-	return refstore.ShortenName(name, names), nil
-}
diff --git a/refstore/packed/store.go b/refstore/packed/store.go
deleted file mode 100644
index 724427ab..00000000
--- a/refstore/packed/store.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// Package packed provides a packed refs backend.
-package packed
-
-import (
-	"codeberg.org/lindenii/furgit/ref"
-	"codeberg.org/lindenii/furgit/refstore"
-)
-
-// Store reads references from a parsed packed-refs snapshot.
-type Store struct {
-	byName  map[string]ref.Detached
-	ordered []ref.Detached
-}
-
-var _ refstore.ReadingStore = (*Store)(nil)