codespell cleanup

api/cbor_gen.go

···
 				case cbg.MajNegativeInt:
 					extraI = int64(extra)
 					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
+						return fmt.Errorf("int64 negative overflow")
 					}
 					extraI = -1 - extraI
 				default:
···
 				case cbg.MajNegativeInt:
 					extraI = int64(extra)
 					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
+						return fmt.Errorf("int64 negative overflow")
 					}
 					extraI = -1 - extraI
 				default:

docs/feed-proposal.md

···
 
 ## Motivation
 The interface for requesting and getting back feeds is something that I feel is really at the core of what bluesky offers. The user should be able to choose what feeds they subscribe to, feeds should be first class objects, they should be able to be efficiently generated and consumed, and they should be able to trustlessly come from anywhere. 
-Theres a lot of changes we *could* make to the current structure, but I don't want to stray too far from where we are at right now.
+There are a lot of changes we *could* make to the current structure, but I don't want to stray too far from where we are at right now.
 
 
 ```go

indexer/indexer.go

···
 	if post.Reply != nil {
 		replyto, err := ix.GetPost(ctx, post.Reply.Parent.Uri)
 		if err != nil {
-			log.Error("probably shouldnt error when processing a reply to a not-found post")
+			log.Error("probably shouldn't error when processing a reply to a not-found post")
 			return err
 		}
 

lex/gen.go

···
 
 		main, ok := s.Defs["main"]
 		if !ok {
-			return fmt.Errorf("schema %q doesnt have a main def", s.ID)
+			return fmt.Errorf("schema %q doesn't have a main def", s.ID)
 		}
 
 		if main.Type == "procedure" || main.Type == "query" {
···
 
 			main, ok := s.Defs["main"]
 			if !ok {
-				return fmt.Errorf("schema %q doesnt have a main def", s.ID)
+				return fmt.Errorf("schema %q doesn't have a main def", s.ID)
 			}
 
 			if main.Type == "procedure" || main.Type == "query" {

mst/cbor_gen.go

···
 				case cbg.MajNegativeInt:
 					extraI = int64(extra)
 					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
+						return fmt.Errorf("int64 negative overflow")
 					}
 					extraI = -1 - extraI
 				default:

mst/diff.go

···
 	}
 }
 
-// TODO: this code isnt great, should be rewritten on top of the baseline datastructures once functional and correct
+// TODO: this code isn't great, should be rewritten on top of the baseline datastructures once functional and correct
 func DiffTrees(ctx context.Context, bs blockstore.Blockstore, from, to cid.Cid) ([]*DiffOp, error) {
 	cst := cbor.NewCborStore(bs)
 

mst/mst.go

···
 func checkTreeInvariant(ents []NodeEntry) {
 	for i := 0; i < len(ents)-1; i++ {
 		if ents[i].isTree() && ents[i+1].isTree() {
-			panic(fmt.Sprintf("two trees next to eachother! %d %d", i, i+1))
+			panic(fmt.Sprintf("two trees next to each other! %d %d", i, i+1))
 		}
 	}
 }

repo/cbor_gen.go

···
 				case cbg.MajNegativeInt:
 					extraI = int64(extra)
 					if extraI < 0 {
-						return fmt.Errorf("int64 negative oveflow")
+						return fmt.Errorf("int64 negative overflow")
 					}
 					extraI = -1 - extraI
 				default:

server/auth.go

···
 	accessTok := makeToken(otherpds, "com.atproto.federation", time.Now().Add(24*time.Hour))
 
 	// setting this is a little weird,
-	// since the token isnt signed by this key, we dont have a way to validate...
+	// since the token isn't signed by this key, we dont have a way to validate...
 	accessTok.Set("pds", s.signingKey.DID())
 
 	rval := make([]byte, 10)