*: Lint v0.1.68

14 files changed, 66 insertions, 66 deletions

diff --git a/format/pack/ingest/drain.go b/format/pack/ingest/drain.go
index b92683c3..671423fb 100644
--- a/format/pack/ingest/drain.go
+++ b/format/pack/ingest/drain.go
@@ -18,7 +18,7 @@ func drainEntryPayload(state *ingestState, record objectRecord) (int64, uint64,
 
 	reader, err := zlib.NewReader(state.stream)
 	if err != nil {
-		return 0, 0, zero, &ErrMalformedPackEntry{Offset: record.offset, Reason: fmt.Sprintf("open zlib stream: %v", err)}
+		return 0, 0, zero, &MalformedPackEntryError{Offset: record.offset, Reason: fmt.Sprintf("open zlib stream: %v", err)}
 	}
 
 	defer func() { _ = reader.Close() }()
@@ -28,7 +28,7 @@ func drainEntryPayload(state *ingestState, record objectRecord) (int64, uint64,
 	if packfmt.IsBaseObjectType(record.packedType) {
 		header, ok := objectheader.Encode(record.packedType, record.declaredSize)
 		if !ok {
-			return 0, 0, zero, &ErrMalformedPackEntry{Offset: record.offset, Reason: "encode object header"}
+			return 0, 0, zero, &MalformedPackEntryError{Offset: record.offset, Reason: "encode object header"}
 		}
 
 		hashImpl, err := state.algo.New()
@@ -40,7 +40,7 @@ func drainEntryPayload(state *ingestState, record objectRecord) (int64, uint64,
 
 		n, err := io.Copy(hashImpl, reader)
 		if err != nil {
-			return 0, 0, zero, &ErrMalformedPackEntry{Offset: record.offset, Reason: fmt.Sprintf("inflate base object: %v", err)}
+			return 0, 0, zero, &MalformedPackEntryError{Offset: record.offset, Reason: fmt.Sprintf("inflate base object: %v", err)}
 		}
 
 		total = n
@@ -56,7 +56,7 @@ func drainEntryPayload(state *ingestState, record objectRecord) (int64, uint64,
 	if record.packedType == objecttype.TypeOfsDelta || record.packedType == objecttype.TypeRefDelta {
 		n, err := io.Copy(io.Discard, reader)
 		if err != nil {
-			return 0, 0, zero, &ErrMalformedPackEntry{Offset: record.offset, Reason: fmt.Sprintf("inflate delta payload: %v", err)}
+			return 0, 0, zero, &MalformedPackEntryError{Offset: record.offset, Reason: fmt.Sprintf("inflate delta payload: %v", err)}
 		}
 
 		total = n
@@ -64,5 +64,5 @@ func drainEntryPayload(state *ingestState, record objectRecord) (int64, uint64,
 		return total, reader.InputConsumed(), zero, nil
 	}
 
-	return 0, 0, zero, &ErrMalformedPackEntry{Offset: record.offset, Reason: "unsupported payload type"}
+	return 0, 0, zero, &MalformedPackEntryError{Offset: record.offset, Reason: "unsupported payload type"}
 }
diff --git a/format/pack/ingest/entry.go b/format/pack/ingest/entry.go
index f6c9074e..f89ad4c8 100644
--- a/format/pack/ingest/entry.go
+++ b/format/pack/ingest/entry.go
@@ -22,7 +22,7 @@ func scanOneEntry(state *ingestState, startOffset uint64) (uint64, error) {
 	}
 
 	if contentLen != record.declaredSize {
-		return 0, &ErrMalformedPackEntry{
+		return 0, &MalformedPackEntryError{
 			Offset: startOffset,
 			Reason: fmt.Sprintf("inflated size mismatch got %d want %d", contentLen, record.declaredSize),
 		}
@@ -30,7 +30,7 @@ func scanOneEntry(state *ingestState, startOffset uint64) (uint64, error) {
 
 	endOffset := startOffset + uint64(record.headerLen) + consumedInput
 	if endOffset > state.stream.consumed {
-		return 0, &ErrMalformedPackEntry{
+		return 0, &MalformedPackEntryError{
 			Offset: startOffset,
 			Reason: fmt.Sprintf("entry end offset overflow got %d > stream %d", endOffset, state.stream.consumed),
 		}
@@ -40,7 +40,7 @@ func scanOneEntry(state *ingestState, startOffset uint64) (uint64, error) {
 
 	record.dataOffset = startOffset + uint64(record.headerLen)
 	if record.packedLen < uint64(record.headerLen) {
-		return 0, &ErrMalformedPackEntry{Offset: startOffset, Reason: "negative payload span"}
+		return 0, &MalformedPackEntryError{Offset: startOffset, Reason: "negative payload span"}
 	}
 
 	crc, err := state.stream.endEntryCRC()
diff --git a/format/pack/ingest/entry_prefix.go b/format/pack/ingest/entry_prefix.go
index 6ffb1c56..85493798 100644
--- a/format/pack/ingest/entry_prefix.go
+++ b/format/pack/ingest/entry_prefix.go
@@ -16,7 +16,7 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 
 	first, err := state.stream.ReadByte()
 	if err != nil {
-		return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("read first header byte: %v", err)}
+		return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("read first header byte: %v", err)}
 	}
 
 	record.packedType = objecttype.Type((first >> 4) & 0x07)
@@ -28,7 +28,7 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 	for b&0x80 != 0 {
 		b, err = state.stream.ReadByte()
 		if err != nil {
-			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("read size continuation: %v", err)}
+			return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("read size continuation: %v", err)}
 		}
 
 		headerLen++
@@ -37,7 +37,7 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 	}
 
 	if size < 0 {
-		return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: "negative declared size"}
+		return record, &MalformedPackEntryError{Offset: startOffset, Reason: "negative declared size"}
 	}
 
 	record.declaredSize = size
@@ -49,12 +49,12 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 
 		err := state.stream.readFull(baseRaw)
 		if err != nil {
-			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("read ref base: %v", err)}
+			return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("read ref base: %v", err)}
 		}
 
 		baseID, err := objectid.FromBytes(state.algo, baseRaw)
 		if err != nil {
-			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("parse ref base: %v", err)}
+			return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("parse ref base: %v", err)}
 		}
 
 		record.baseObject = baseID
@@ -68,11 +68,11 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 	case objecttype.TypeOfsDelta:
 		dist, consumed, err := readOfsDistanceFromStream(state.stream)
 		if err != nil {
-			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: err.Error()}
+			return record, &MalformedPackEntryError{Offset: startOffset, Reason: err.Error()}
 		}
 
 		if startOffset <= dist {
-			return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: "ofs base offset out of bounds"}
+			return record, &MalformedPackEntryError{Offset: startOffset, Reason: "ofs base offset out of bounds"}
 		}
 
 		record.baseOffset = startOffset - dist
@@ -84,9 +84,9 @@ func parseEntryPrefix(state *ingestState, startOffset uint64) (objectRecord, err
 
 		headerLen += consumedUint32
 	case objecttype.TypeInvalid, objecttype.TypeFuture:
-		return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("unsupported object type %d", record.packedType)}
+		return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("unsupported object type %d", record.packedType)}
 	default:
-		return record, &ErrMalformedPackEntry{Offset: startOffset, Reason: fmt.Sprintf("unsupported object type %d", record.packedType)}
+		return record, &MalformedPackEntryError{Offset: startOffset, Reason: fmt.Sprintf("unsupported object type %d", record.packedType)}
 	}
 
 	record.headerLen = headerLen
diff --git a/format/pack/ingest/errors.go b/format/pack/ingest/errors.go
index cd65d3cf..82b662b5 100644
--- a/format/pack/ingest/errors.go
+++ b/format/pack/ingest/errors.go
@@ -5,64 +5,64 @@ import (
 	"fmt"
 )
 
-// ErrInvalidPackHeader reports an invalid or unsupported pack header.
-type ErrInvalidPackHeader struct {
+// InvalidPackHeaderError reports an invalid or unsupported pack header.
+type InvalidPackHeaderError struct {
 	Reason string
 }
 
 // Error implements error.
-func (err *ErrInvalidPackHeader) Error() string {
-	return fmt.Sprintf("format/pack/ingest: invalid pack header: %s", err.Reason)
+func (err *InvalidPackHeaderError) Error() string {
+	return "format/pack/ingest: invalid pack header: " + err.Reason
 }
 
-// ErrPackTrailerMismatch reports a mismatch between computed and trailer pack hash.
-type ErrPackTrailerMismatch struct{}
+// PackTrailerMismatchError reports a mismatch between computed and trailer pack hash.
+type PackTrailerMismatchError struct{}
 
 // Error implements error.
-func (err *ErrPackTrailerMismatch) Error() string {
+func (err *PackTrailerMismatchError) Error() string {
 	return "format/pack/ingest: pack trailer hash mismatch"
 }
 
-// ErrThinPackUnresolved reports unresolved REF deltas when fixThin is disabled
+// ThinPackUnresolvedError reports unresolved REF deltas when fixThin is disabled
 // or when required bases cannot be found in base.
-type ErrThinPackUnresolved struct {
+type ThinPackUnresolvedError struct {
 	Count int
 }
 
 // Error implements error.
-func (err *ErrThinPackUnresolved) Error() string {
+func (err *ThinPackUnresolvedError) Error() string {
 	return fmt.Sprintf("format/pack/ingest: unresolved thin deltas: %d", err.Count)
 }
 
-// ErrMalformedPackEntry reports malformed entry encoding at one pack offset.
-type ErrMalformedPackEntry struct {
+// MalformedPackEntryError reports malformed entry encoding at one pack offset.
+type MalformedPackEntryError struct {
 	Offset uint64
 	Reason string
 }
 
 // Error implements error.
-func (err *ErrMalformedPackEntry) Error() string {
+func (err *MalformedPackEntryError) Error() string {
 	return fmt.Sprintf("format/pack/ingest: malformed pack entry at offset %d: %s", err.Offset, err.Reason)
 }
 
-// ErrDeltaCycle reports a detected cycle in delta dependency resolution.
-type ErrDeltaCycle struct {
+// DeltaCycleError reports a detected cycle in delta dependency resolution.
+type DeltaCycleError struct {
 	Offset uint64
 }
 
 // Error implements error.
-func (err *ErrDeltaCycle) Error() string {
+func (err *DeltaCycleError) Error() string {
 	return fmt.Sprintf("format/pack/ingest: delta cycle detected at offset %d", err.Offset)
 }
 
-// ErrDestinationWrite reports destination I/O failures.
-type ErrDestinationWrite struct {
+// DestinationWriteError reports destination I/O failures.
+type DestinationWriteError struct {
 	Op string
 }
 
 // Error implements error.
-func (err *ErrDestinationWrite) Error() string {
-	return fmt.Sprintf("format/pack/ingest: destination write failure: %s", err.Op)
+func (err *DestinationWriteError) Error() string {
+	return "format/pack/ingest: destination write failure: " + err.Op
 }
 
 var errExternalThinBase = errors.New("format/pack/ingest: external thin base required")
diff --git a/format/pack/ingest/flush.go b/format/pack/ingest/flush.go
index 4742ead1..96753170 100644
--- a/format/pack/ingest/flush.go
+++ b/format/pack/ingest/flush.go
@@ -18,11 +18,11 @@ func (scanner *streamScanner) flushConsumedPrefix() error {
 	for written < scanner.off {
 		n, err := scanner.dstFile.Write(scanner.buf[written:scanner.off])
 		if err != nil {
-			return &ErrDestinationWrite{Op: fmt.Sprintf("write pack: %v", err)}
+			return &DestinationWriteError{Op: fmt.Sprintf("write pack: %v", err)}
 		}
 
 		if n == 0 {
-			return &ErrDestinationWrite{Op: "write pack: short write"}
+			return &DestinationWriteError{Op: "write pack: short write"}
 		}
 
 		written += n
diff --git a/format/pack/ingest/header.go b/format/pack/ingest/header.go
index 88663760..fba2b175 100644
--- a/format/pack/ingest/header.go
+++ b/format/pack/ingest/header.go
@@ -13,21 +13,21 @@ func readAndValidatePackHeader(state *ingestState) error {
 
 	err := state.stream.readFull(hdr[:])
 	if err != nil {
-		return &ErrInvalidPackHeader{Reason: fmt.Sprintf("read header: %v", err)}
+		return &InvalidPackHeaderError{Reason: fmt.Sprintf("read header: %v", err)}
 	}
 
 	if binary.BigEndian.Uint32(hdr[:4]) != pack.Signature {
-		return &ErrInvalidPackHeader{Reason: "signature mismatch"}
+		return &InvalidPackHeaderError{Reason: "signature mismatch"}
 	}
 
 	version := binary.BigEndian.Uint32(hdr[4:8])
 	if !pack.VersionSupported(version) {
-		return &ErrInvalidPackHeader{Reason: fmt.Sprintf("unsupported version %d", version)}
+		return &InvalidPackHeaderError{Reason: fmt.Sprintf("unsupported version %d", version)}
 	}
 
 	state.objectCountHeader = binary.BigEndian.Uint32(hdr[8:12])
 	if state.objectCountHeader == 0 {
-		return &ErrInvalidPackHeader{Reason: "zero objects"}
+		return &InvalidPackHeaderError{Reason: "zero objects"}
 	}
 
 	return nil
diff --git a/format/pack/ingest/ingest.go b/format/pack/ingest/ingest.go
index df6c6627..22007d27 100644
--- a/format/pack/ingest/ingest.go
+++ b/format/pack/ingest/ingest.go
@@ -39,7 +39,7 @@ func ingest(state *ingestState) (out Result, err error) {
 	}
 
 	if len(state.unresolvedRefDeltas) > 0 {
-		return Result{}, &ErrThinPackUnresolved{Count: len(state.unresolvedRefDeltas)}
+		return Result{}, &ThinPackUnresolvedError{Count: len(state.unresolvedRefDeltas)}
 	}
 
 	err = verifyResolvedRecords(state)
@@ -49,7 +49,7 @@ func ingest(state *ingestState) (out Result, err error) {
 
 	err = state.packFile.Sync()
 	if err != nil {
-		return Result{}, &ErrDestinationWrite{Op: fmt.Sprintf("sync pack: %v", err)}
+		return Result{}, &DestinationWriteError{Op: fmt.Sprintf("sync pack: %v", err)}
 	}
 
 	err = writeIdx(state)
diff --git a/format/pack/ingest/ingest_test.go b/format/pack/ingest/ingest_test.go
index 1bc2ec0f..13f7ee85 100644
--- a/format/pack/ingest/ingest_test.go
+++ b/format/pack/ingest/ingest_test.go
@@ -246,9 +246,9 @@ func TestIngestThinPackWithoutFixReturnsUnresolved(t *testing.T) {
 			t.Fatal("Ingest error = nil, want error")
 		}
 
-		var unresolved *ingest.ErrThinPackUnresolved
+		var unresolved *ingest.ThinPackUnresolvedError
 		if !errors.As(err, &unresolved) {
-			t.Fatalf("Ingest error type = %T (%v), want *ErrThinPackUnresolved", err, err)
+			t.Fatalf("Ingest error type = %T (%v), want *ThinPackUnresolvedError", err, err)
 		}
 
 		matches, err := filepath.Glob(filepath.Join(packDir, "pack-*.pack"))
@@ -362,9 +362,9 @@ func TestIngestPackTrailerMismatch(t *testing.T) {
 			t.Fatal("Ingest error = nil, want error")
 		}
 
-		var mismatch *ingest.ErrPackTrailerMismatch
+		var mismatch *ingest.PackTrailerMismatchError
 		if !errors.As(err, &mismatch) {
-			t.Fatalf("Ingest error type = %T (%v), want *ErrPackTrailerMismatch", err, err)
+			t.Fatalf("Ingest error type = %T (%v), want *PackTrailerMismatchError", err, err)
 		}
 
 		matches, err := filepath.Glob(filepath.Join(packDir, "pack-*.pack"))
diff --git a/format/pack/ingest/record_content.go b/format/pack/ingest/record_content.go
index 1d4f27c3..8fef44b9 100644
--- a/format/pack/ingest/record_content.go
+++ b/format/pack/ingest/record_content.go
@@ -20,7 +20,7 @@ func readBaseRecordContent(state *ingestState, idx int) (objecttype.Type, []byte
 	}
 
 	if int64(len(content)) != record.declaredSize {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("base content size mismatch got %d want %d", len(content), record.declaredSize),
 		}
diff --git a/format/pack/ingest/record_delta.go b/format/pack/ingest/record_delta.go
index 67db608e..4a3d5810 100644
--- a/format/pack/ingest/record_delta.go
+++ b/format/pack/ingest/record_delta.go
@@ -20,7 +20,7 @@ func applyDeltaRecord(state *ingestState, idx int, baseType objecttype.Type, bas
 	}
 
 	if int64(len(deltaPayload)) != record.declaredSize {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("delta payload size mismatch got %d want %d", len(deltaPayload), record.declaredSize),
 		}
@@ -28,14 +28,14 @@ func applyDeltaRecord(state *ingestState, idx int, baseType objecttype.Type, bas
 
 	srcSize, dstSize, err := readDeltaHeaderSizes(deltaPayload)
 	if err != nil {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("read delta header: %v", err),
 		}
 	}
 
 	if srcSize != len(baseContent) {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("delta source size mismatch got %d want %d", srcSize, len(baseContent)),
 		}
@@ -43,14 +43,14 @@ func applyDeltaRecord(state *ingestState, idx int, baseType objecttype.Type, bas
 
 	content, err := deltaapply.Apply(baseContent, deltaPayload)
 	if err != nil {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("apply delta: %v", err),
 		}
 	}
 
 	if len(content) != dstSize {
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: fmt.Sprintf("delta result size mismatch got %d want %d", len(content), dstSize),
 		}
diff --git a/format/pack/ingest/record_inflate.go b/format/pack/ingest/record_inflate.go
index a8d68c07..b8eca25b 100644
--- a/format/pack/ingest/record_inflate.go
+++ b/format/pack/ingest/record_inflate.go
@@ -12,7 +12,7 @@ import (
 func inflateRecordPayload(state *ingestState, idx int) ([]byte, error) {
 	record := state.records[idx]
 	if record.packedLen < uint64(record.headerLen) {
-		return nil, &ErrMalformedPackEntry{Offset: record.offset, Reason: "entry packed span underflow"}
+		return nil, &MalformedPackEntryError{Offset: record.offset, Reason: "entry packed span underflow"}
 	}
 
 	compressedOffset := record.offset + uint64(record.headerLen)
@@ -32,14 +32,14 @@ func inflateRecordPayload(state *ingestState, idx int) ([]byte, error) {
 
 	reader, err := zlib.NewReader(section)
 	if err != nil {
-		return nil, &ErrMalformedPackEntry{Offset: record.offset, Reason: fmt.Sprintf("open payload zlib: %v", err)}
+		return nil, &MalformedPackEntryError{Offset: record.offset, Reason: fmt.Sprintf("open payload zlib: %v", err)}
 	}
 
 	defer func() { _ = reader.Close() }()
 
 	out, err := io.ReadAll(reader)
 	if err != nil {
-		return nil, &ErrMalformedPackEntry{Offset: record.offset, Reason: fmt.Sprintf("inflate payload: %v", err)}
+		return nil, &MalformedPackEntryError{Offset: record.offset, Reason: fmt.Sprintf("inflate payload: %v", err)}
 	}
 
 	return out, nil
diff --git a/format/pack/ingest/record_resolve.go b/format/pack/ingest/record_resolve.go
index 6ef5e857..fad8ee7f 100644
--- a/format/pack/ingest/record_resolve.go
+++ b/format/pack/ingest/record_resolve.go
@@ -14,7 +14,7 @@ func resolveRecord(state *ingestState, idx int, visiting map[int]struct{}) (obje
 	}
 
 	if _, ok := visiting[idx]; ok {
-		return objecttype.TypeInvalid, nil, &ErrDeltaCycle{Offset: state.records[idx].offset}
+		return objecttype.TypeInvalid, nil, &DeltaCycleError{Offset: state.records[idx].offset}
 	}
 
 	visiting[idx] = struct{}{}
@@ -60,7 +60,7 @@ func resolveRecord(state *ingestState, idx int, visiting map[int]struct{}) (obje
 	case objecttype.TypeOfsDelta:
 		baseIdx, ok := state.offsetToRecord[record.baseOffset]
 		if !ok {
-			return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+			return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 				Offset: record.offset,
 				Reason: "missing ofs-delta base entry",
 			}
@@ -86,12 +86,12 @@ func resolveRecord(state *ingestState, idx int, visiting map[int]struct{}) (obje
 		objecttype.TypeBlob,
 		objecttype.TypeTag,
 		objecttype.TypeFuture:
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: "unsupported delta type",
 		}
 	default:
-		return objecttype.TypeInvalid, nil, &ErrMalformedPackEntry{
+		return objecttype.TypeInvalid, nil, &MalformedPackEntryError{
 			Offset: record.offset,
 			Reason: "unsupported delta type",
 		}
diff --git a/format/pack/ingest/thin_fix.go b/format/pack/ingest/thin_fix.go
index 65ce131c..f21ef98a 100644
--- a/format/pack/ingest/thin_fix.go
+++ b/format/pack/ingest/thin_fix.go
@@ -13,11 +13,11 @@ func maybeFixThin(state *ingestState) error {
 	}
 
 	if !state.fixThin {
-		return &ErrThinPackUnresolved{Count: len(state.unresolvedRefDeltas)}
+		return &ThinPackUnresolvedError{Count: len(state.unresolvedRefDeltas)}
 	}
 
 	if state.base == nil {
-		return &ErrThinPackUnresolved{Count: len(state.unresolvedRefDeltas)}
+		return &ThinPackUnresolvedError{Count: len(state.unresolvedRefDeltas)}
 	}
 
 	hashSize := int64(state.algo.Size())
diff --git a/format/pack/ingest/trailer.go b/format/pack/ingest/trailer.go
index 4dba3884..ea945b10 100644
--- a/format/pack/ingest/trailer.go
+++ b/format/pack/ingest/trailer.go
@@ -20,7 +20,7 @@ func (scanner *streamScanner) finishAndFlushTrailer() error {
 
 	err := scanner.readFull(trailer)
 	if err != nil {
-		return &ErrPackTrailerMismatch{}
+		return &PackTrailerMismatchError{}
 	}
 
 	scanner.packTrailer = append(scanner.packTrailer[:0], trailer...)
@@ -38,7 +38,7 @@ func (scanner *streamScanner) finishAndFlushTrailer() error {
 
 	computed := scanner.hash.Sum(nil)
 	if !bytes.Equal(computed, trailer) {
-		return &ErrPackTrailerMismatch{}
+		return &PackTrailerMismatchError{}
 	}
 
 	return nil