This PR refactors the plumbing/protocol/packp package to simplify the AdvRefs encoder/decoder, clean up the capability package, and remove unnecessary constructors.

Motivation

AdvRefs loses information

The old AdvRefs stored references in two maps (References and Peeled) that lost wire-order information. Most consumers called MakeReferenceSlice() immediately—the maps were an intermediate representation nobody wanted. The git pack protocol defines advertised-refs as an ordered sequence where peeled refs follow their base ref. The current representation didn't preserve this.

Capability type forces conversions

Capability was a defined type requiring conversions like capability.Capability("custom-cap"). Protocol v2's arbitrary command capabilities multiply this friction. A type alias eliminates conversions while keeping the named constants.

capability.List validation is counterproductive

List.Add() and Set() returned errors that callers universally discarded. Every call site discards the error. The validation maps enforce rules that callers already know. Worse, the known map becomes a liability for v2: unknown capabilities bypass validation silently.

Constructors exist only to initialize maps

Every packp constructor (NewAdvRefs, NewUploadRequest, etc.) existed primarily to call capability.NewList(), which existed to make(map[...]). If List is zero-value safe, all constructors become unnecessary.

Changes

capability.List zero-value safety

• Added lazy init to List.Add(), Set(), and other methods
• Made List zero-value safe—first write creates the internal map
• Removed NewList()—use &List{} or zero value

Capability type alias

• Changed type Capability string to type Capability = string
• Eliminated conversion friction for protocol v2
• Removed validation maps and error types
• Made Add/Set infallible (no error return)

Wire format moved out of List

• Replaced List.Decode with package-level DecodeList
• v0/v1 uses space-separated capabilities; v2 uses line-separated
• Keeping List protocol-agnostic: it's now a pure container type

AdvRefs slice migration

• Replaced References map[string]Hash and Peeled map[string]Hash with single References []*Reference slice
• Added ReferenceName.IsPeeled() helper (consistent with IsTag(), IsBranch())
• Removed NewAdvRefs(), AddReference(), MakeReferenceSlice(), IsEmpty()

AdvRefs encoder/decoder simplification

• Removed state machine pattern from encoder (5 state functions → single Encode() method)
• Removed state machine pattern from decoder (8 state functions → single Decode() method with loop)
• Net reduction of 145 lines of code

Constructor removal and zero-value safety

• Removed NewUploadRequest, NewUpdateRequests, NewReportStatus
• Types are zero-value safe: nil slices work with append, Capabilities is value type

DepthRequest struct replaces Depth interface

The old Depth interface used a sum-type pattern (DepthCommits, DepthSince, DepthReference) that couldn't represent the full git protocol. Specifically:

• Couldn't combine deepen-since with deepen-not (git allows this)
• Couldn't specify multiple deepen-not refs (git uses an oidset)
• Required a constructor just to set a non-nil default

The new DepthRequest struct matches how canonical git C handles it:

type DepthRequest struct {
    Commits int           // "deepen <n>" - 0 means no limit
    Since   time.Time     // "deepen-since <timestamp>"
    NotRefs []string      // Multiple "deepen-not <ref>" lines
}

This matches git's upload_pack_data struct which stores depth as separate fields, not a sum type. The zero value (all fields empty/zero) means "no depth constraint" which is the correct default for infinite depth.

Added validation: Following canonical git, the encoder and decoder now reject invalid combinations:

• deepen <n> cannot be combined with deepen-since or deepen-not
• Error message matches git: "deepen and deepen-since (or deepen-not) cannot be used together"

Benchmarks

Before (transport-migrate/base: 3 runs):

BenchmarkPlainClone-16    3    341770083 ns/op    3742216 B/op    34587 allocs/op
BenchmarkPlainClone-16    3    345509806 ns/op    3472776 B/op    34530 allocs/op
BenchmarkPlainClone-16    4    329814698 ns/op    3562374 B/op    34564 allocs/op

After (packp-refactoring: 3 runs):

BenchmarkPlainClone-16    3    346557236 ns/op    2984754 B/op    29572 allocs/op
BenchmarkPlainClone-16    3    335943014 ns/op    2855368 B/op    29477 allocs/op
BenchmarkPlainClone-16    3    349759278 ns/op    2876133 B/op    29320 allocs/op

Improvement:

• Memory: ~3.6MB → ~2.9MB (~19% reduction in allocations)
• Allocs: ~34,500 → ~29,500 (~14% reduction)

Migration Guide

Testing

All existing tests pass:

• go test ./plumbing/protocol/packp/...
• go test ./plumbing/protocol/capability/...
• make validate passes (0 lint issues)