Merge branch 'main' into bnewbold/omitempty-params

api/agnostic/actorgetPreferences.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorGetPreferences_Output is the output of a app.bsky.actor.getPreferences call.
···
 }
 
 // ActorGetPreferences calls the XRPC method "app.bsky.actor.getPreferences".
-func ActorGetPreferences(ctx context.Context, c *xrpc.Client) (*ActorGetPreferences_Output, error) {
+func ActorGetPreferences(ctx context.Context, c util.LexClient) (*ActorGetPreferences_Output, error) {
 	var out ActorGetPreferences_Output
 
 	params := map[string]interface{}{}
-	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.actor.getPreferences", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "app.bsky.actor.getPreferences", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/actorputPreferences.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // ActorPutPreferences_Input is the input argument to a app.bsky.actor.putPreferences call.
···
 }
 
 // ActorPutPreferences calls the XRPC method "app.bsky.actor.putPreferences".
-func ActorPutPreferences(ctx context.Context, c *xrpc.Client, input *ActorPutPreferences_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "app.bsky.actor.putPreferences", nil, input, nil); err != nil {
+func ActorPutPreferences(ctx context.Context, c util.LexClient, input *ActorPutPreferences_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "app.bsky.actor.putPreferences", nil, input, nil); err != nil {
 		return err
 	}
 

api/agnostic/identitygetRecommendedDidCredentials.go

···
 	"context"
 	"encoding/json"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentityGetRecommendedDidCredentials calls the XRPC method "com.atproto.identity.getRecommendedDidCredentials".
-func IdentityGetRecommendedDidCredentials(ctx context.Context, c *xrpc.Client) (*json.RawMessage, error) {
+func IdentityGetRecommendedDidCredentials(ctx context.Context, c util.LexClient) (*json.RawMessage, error) {
 	var out json.RawMessage
 
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.identity.getRecommendedDidCredentials", nil, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.identity.getRecommendedDidCredentials", nil, nil, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/identitysignPlcOperation.go

···
 	"context"
 	"encoding/json"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentitySignPlcOperation_Input is the input argument to a com.atproto.identity.signPlcOperation call.
···
 }
 
 // IdentitySignPlcOperation calls the XRPC method "com.atproto.identity.signPlcOperation".
-func IdentitySignPlcOperation(ctx context.Context, c *xrpc.Client, input *IdentitySignPlcOperation_Input) (*IdentitySignPlcOperation_Output, error) {
+func IdentitySignPlcOperation(ctx context.Context, c util.LexClient, input *IdentitySignPlcOperation_Input) (*IdentitySignPlcOperation_Output, error) {
 	var out IdentitySignPlcOperation_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.signPlcOperation", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.signPlcOperation", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/identitysubmitPlcOperation.go

···
 	"context"
 	"encoding/json"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // IdentitySubmitPlcOperation_Input is the input argument to a com.atproto.identity.submitPlcOperation call.
···
 }
 
 // IdentitySubmitPlcOperation calls the XRPC method "com.atproto.identity.submitPlcOperation".
-func IdentitySubmitPlcOperation(ctx context.Context, c *xrpc.Client, input *IdentitySubmitPlcOperation_Input) error {
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.identity.submitPlcOperation", nil, input, nil); err != nil {
+func IdentitySubmitPlcOperation(ctx context.Context, c util.LexClient, input *IdentitySubmitPlcOperation_Input) error {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.identity.submitPlcOperation", nil, input, nil); err != nil {
 		return err
 	}
 

api/agnostic/repoapplyWrites.go

···
 	"fmt"
 
 	"github.com/bluesky-social/indigo/lex/util"
-	"github.com/bluesky-social/indigo/xrpc"
 )
 
 // RepoApplyWrites_Create is a "create" in the com.atproto.repo.applyWrites schema.
···
 }
 
 // RepoApplyWrites calls the XRPC method "com.atproto.repo.applyWrites".
-func RepoApplyWrites(ctx context.Context, c *xrpc.Client, input *RepoApplyWrites_Input) (*RepoApplyWrites_Output, error) {
+func RepoApplyWrites(ctx context.Context, c util.LexClient, input *RepoApplyWrites_Input) (*RepoApplyWrites_Output, error) {
 	var out RepoApplyWrites_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.applyWrites", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/repocreateRecord.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoDefs_CommitMeta is a "commitMeta" in the com.atproto.repo.defs schema.
···
 }
 
 // RepoCreateRecord calls the XRPC method "com.atproto.repo.createRecord".
-func RepoCreateRecord(ctx context.Context, c *xrpc.Client, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
+func RepoCreateRecord(ctx context.Context, c util.LexClient, input *RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {
 	var out RepoCreateRecord_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.createRecord", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/repogetRecord.go

···
 	"context"
 	"encoding/json"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoGetRecord_Output is the output of a com.atproto.repo.getRecord call.
···
 // collection: The NSID of the record collection.
 // repo: The handle or DID of the repo.
 // rkey: The Record Key.
-func RepoGetRecord(ctx context.Context, c *xrpc.Client, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
+func RepoGetRecord(ctx context.Context, c util.LexClient, cid string, collection string, repo string, rkey string) (*RepoGetRecord_Output, error) {
 	var out RepoGetRecord_Output
 
 	params := map[string]interface{}{
···
 	if cid != "" {
 		params["cid"] = cid
 	}
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.getRecord", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/repolistRecords.go

···
 	"context"
 	"encoding/json"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoListRecords_Output is the output of a com.atproto.repo.listRecords call.
···
 // limit: The number of records to return.
 // repo: The handle or DID of the repo.
 // reverse: Flag to reverse the order of the returned records.
-func RepoListRecords(ctx context.Context, c *xrpc.Client, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
+func RepoListRecords(ctx context.Context, c util.LexClient, collection string, cursor string, limit int64, repo string, reverse bool) (*RepoListRecords_Output, error) {
 	var out RepoListRecords_Output
 
 	params := map[string]interface{}{
···
 		params["reverse"] = reverse
 	}
 
-	if err := c.Do(ctx, xrpc.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
+	if err := c.LexDo(ctx, util.Query, "", "com.atproto.repo.listRecords", params, nil, &out); err != nil {
 		return nil, err
 	}
 

api/agnostic/repoputRecord.go

···
 import (
 	"context"
 
-	"github.com/bluesky-social/indigo/xrpc"
+	"github.com/bluesky-social/indigo/lex/util"
 )
 
 // RepoPutRecord_Input is the input argument to a com.atproto.repo.putRecord call.
···
 }
 
 // RepoPutRecord calls the XRPC method "com.atproto.repo.putRecord".
-func RepoPutRecord(ctx context.Context, c *xrpc.Client, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
+func RepoPutRecord(ctx context.Context, c util.LexClient, input *RepoPutRecord_Input) (*RepoPutRecord_Output, error) {
 	var out RepoPutRecord_Output
-	if err := c.Do(ctx, xrpc.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {
+	if err := c.LexDo(ctx, util.Procedure, "application/json", "com.atproto.repo.putRecord", nil, input, &out); err != nil {
 		return nil, err
 	}
 

api/atproto/cbor_gen.go

···
 
 	return nil
 }
-func (t *SyncSubscribeRepos_Handle) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
 
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write([]byte{164}); err != nil {
-		return err
-	}
-
-	// t.Did (string) (string)
-	if len("did") > 1000000 {
-		return xerrors.Errorf("Value in field \"did\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("did")); err != nil {
-		return err
-	}
-
-	if len(t.Did) > 1000000 {
-		return xerrors.Errorf("Value in field t.Did was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Did)); err != nil {
-		return err
-	}
-
-	// t.Seq (int64) (int64)
-	if len("seq") > 1000000 {
-		return xerrors.Errorf("Value in field \"seq\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("seq"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("seq")); err != nil {
-		return err
-	}
-
-	if t.Seq >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Seq-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.Time (string) (string)
-	if len("time") > 1000000 {
-		return xerrors.Errorf("Value in field \"time\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("time")); err != nil {
-		return err
-	}
-
-	if len(t.Time) > 1000000 {
-		return xerrors.Errorf("Value in field t.Time was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Time)); err != nil {
-		return err
-	}
-
-	// t.Handle (string) (string)
-	if len("handle") > 1000000 {
-		return xerrors.Errorf("Value in field \"handle\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("handle"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("handle")); err != nil {
-		return err
-	}
-
-	if len(t.Handle) > 1000000 {
-		return xerrors.Errorf("Value in field t.Handle was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Handle))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Handle)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SyncSubscribeRepos_Handle) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = SyncSubscribeRepos_Handle{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("SyncSubscribeRepos_Handle: map struct too large (%d)", extra)
-	}
-
-	n := extra
-
-	nameBuf := make([]byte, 6)
-	for i := uint64(0); i < n; i++ {
-		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
-		if err != nil {
-			return err
-		}
-
-		if !ok {
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
-				return err
-			}
-			continue
-		}
-
-		switch string(nameBuf[:nameLen]) {
-		// t.Did (string) (string)
-		case "did":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Did = string(sval)
-			}
-			// t.Seq (int64) (int64)
-		case "seq":
-			{
-				maj, extra, err := cr.ReadHeader()
-				if err != nil {
-					return err
-				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.Seq = int64(extraI)
-			}
-			// t.Time (string) (string)
-		case "time":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Time = string(sval)
-			}
-			// t.Handle (string) (string)
-		case "handle":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Handle = string(sval)
-			}
-
-		default:
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
 func (t *SyncSubscribeRepos_Identity) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
···
 
 	return nil
 }
-func (t *SyncSubscribeRepos_Migrate) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
 
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write([]byte{164}); err != nil {
-		return err
-	}
-
-	// t.Did (string) (string)
-	if len("did") > 1000000 {
-		return xerrors.Errorf("Value in field \"did\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("did")); err != nil {
-		return err
-	}
-
-	if len(t.Did) > 1000000 {
-		return xerrors.Errorf("Value in field t.Did was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Did)); err != nil {
-		return err
-	}
-
-	// t.Seq (int64) (int64)
-	if len("seq") > 1000000 {
-		return xerrors.Errorf("Value in field \"seq\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("seq"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("seq")); err != nil {
-		return err
-	}
-
-	if t.Seq >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Seq-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.Time (string) (string)
-	if len("time") > 1000000 {
-		return xerrors.Errorf("Value in field \"time\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("time")); err != nil {
-		return err
-	}
-
-	if len(t.Time) > 1000000 {
-		return xerrors.Errorf("Value in field t.Time was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Time)); err != nil {
-		return err
-	}
-
-	// t.MigrateTo (string) (string)
-	if len("migrateTo") > 1000000 {
-		return xerrors.Errorf("Value in field \"migrateTo\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("migrateTo"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("migrateTo")); err != nil {
-		return err
-	}
-
-	if t.MigrateTo == nil {
-		if _, err := cw.Write(cbg.CborNull); err != nil {
-			return err
-		}
-	} else {
-		if len(*t.MigrateTo) > 1000000 {
-			return xerrors.Errorf("Value in field t.MigrateTo was too long")
-		}
-
-		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.MigrateTo))); err != nil {
-			return err
-		}
-		if _, err := cw.WriteString(string(*t.MigrateTo)); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (t *SyncSubscribeRepos_Migrate) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = SyncSubscribeRepos_Migrate{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("SyncSubscribeRepos_Migrate: map struct too large (%d)", extra)
-	}
-
-	n := extra
-
-	nameBuf := make([]byte, 9)
-	for i := uint64(0); i < n; i++ {
-		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
-		if err != nil {
-			return err
-		}
-
-		if !ok {
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
-				return err
-			}
-			continue
-		}
-
-		switch string(nameBuf[:nameLen]) {
-		// t.Did (string) (string)
-		case "did":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Did = string(sval)
-			}
-			// t.Seq (int64) (int64)
-		case "seq":
-			{
-				maj, extra, err := cr.ReadHeader()
-				if err != nil {
-					return err
-				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.Seq = int64(extraI)
-			}
-			// t.Time (string) (string)
-		case "time":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Time = string(sval)
-			}
-			// t.MigrateTo (string) (string)
-		case "migrateTo":
-
-			{
-				b, err := cr.ReadByte()
-				if err != nil {
-					return err
-				}
-				if b != cbg.CborNull[0] {
-					if err := cr.UnreadByte(); err != nil {
-						return err
-					}
-
-					sval, err := cbg.ReadStringWithMax(cr, 1000000)
-					if err != nil {
-						return err
-					}
-
-					t.MigrateTo = (*string)(&sval)
-				}
-			}
-
-		default:
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
 func (t *SyncSubscribeRepos_RepoOp) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)
···
 
 	return nil
 }
-func (t *SyncSubscribeRepos_Tombstone) MarshalCBOR(w io.Writer) error {
-	if t == nil {
-		_, err := w.Write(cbg.CborNull)
-		return err
-	}
 
-	cw := cbg.NewCborWriter(w)
-
-	if _, err := cw.Write([]byte{163}); err != nil {
-		return err
-	}
-
-	// t.Did (string) (string)
-	if len("did") > 1000000 {
-		return xerrors.Errorf("Value in field \"did\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("did")); err != nil {
-		return err
-	}
-
-	if len(t.Did) > 1000000 {
-		return xerrors.Errorf("Value in field t.Did was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Did)); err != nil {
-		return err
-	}
-
-	// t.Seq (int64) (int64)
-	if len("seq") > 1000000 {
-		return xerrors.Errorf("Value in field \"seq\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("seq"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("seq")); err != nil {
-		return err
-	}
-
-	if t.Seq >= 0 {
-		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Seq)); err != nil {
-			return err
-		}
-	} else {
-		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Seq-1)); err != nil {
-			return err
-		}
-	}
-
-	// t.Time (string) (string)
-	if len("time") > 1000000 {
-		return xerrors.Errorf("Value in field \"time\" was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("time"))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string("time")); err != nil {
-		return err
-	}
-
-	if len(t.Time) > 1000000 {
-		return xerrors.Errorf("Value in field t.Time was too long")
-	}
-
-	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Time))); err != nil {
-		return err
-	}
-	if _, err := cw.WriteString(string(t.Time)); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (t *SyncSubscribeRepos_Tombstone) UnmarshalCBOR(r io.Reader) (err error) {
-	*t = SyncSubscribeRepos_Tombstone{}
-
-	cr := cbg.NewCborReader(r)
-
-	maj, extra, err := cr.ReadHeader()
-	if err != nil {
-		return err
-	}
-	defer func() {
-		if err == io.EOF {
-			err = io.ErrUnexpectedEOF
-		}
-	}()
-
-	if maj != cbg.MajMap {
-		return fmt.Errorf("cbor input should be of type map")
-	}
-
-	if extra > cbg.MaxLength {
-		return fmt.Errorf("SyncSubscribeRepos_Tombstone: map struct too large (%d)", extra)
-	}
-
-	n := extra
-
-	nameBuf := make([]byte, 4)
-	for i := uint64(0); i < n; i++ {
-		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
-		if err != nil {
-			return err
-		}
-
-		if !ok {
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
-				return err
-			}
-			continue
-		}
-
-		switch string(nameBuf[:nameLen]) {
-		// t.Did (string) (string)
-		case "did":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Did = string(sval)
-			}
-			// t.Seq (int64) (int64)
-		case "seq":
-			{
-				maj, extra, err := cr.ReadHeader()
-				if err != nil {
-					return err
-				}
-				var extraI int64
-				switch maj {
-				case cbg.MajUnsignedInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 positive overflow")
-					}
-				case cbg.MajNegativeInt:
-					extraI = int64(extra)
-					if extraI < 0 {
-						return fmt.Errorf("int64 negative overflow")
-					}
-					extraI = -1 - extraI
-				default:
-					return fmt.Errorf("wrong type for int64 field: %d", maj)
-				}
-
-				t.Seq = int64(extraI)
-			}
-			// t.Time (string) (string)
-		case "time":
-
-			{
-				sval, err := cbg.ReadStringWithMax(cr, 1000000)
-				if err != nil {
-					return err
-				}
-
-				t.Time = string(sval)
-			}
-
-		default:
-			// Field doesn't exist on this type, so ignore it
-			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
 func (t *LabelDefs_SelfLabels) MarshalCBOR(w io.Writer) error {
 	if t == nil {
 		_, err := w.Write(cbg.CborNull)

api/atproto/syncsubscribeRepos.go

···
 	TooBig bool `json:"tooBig" cborgen:"tooBig"`
 }
 
-// SyncSubscribeRepos_Handle is a "handle" in the com.atproto.sync.subscribeRepos schema.
-//
-// DEPRECATED -- Use #identity event instead
-type SyncSubscribeRepos_Handle struct {
-	Did    string `json:"did" cborgen:"did"`
-	Handle string `json:"handle" cborgen:"handle"`
-	Seq    int64  `json:"seq" cborgen:"seq"`
-	Time   string `json:"time" cborgen:"time"`
-}
-
 // SyncSubscribeRepos_Identity is a "identity" in the com.atproto.sync.subscribeRepos schema.
 //
 // Represents a change to an account's identity. Could be an updated handle, signing key, or pds hosting endpoint. Serves as a prod to all downstream services to refresh their identity cache.
···
 	Name    string  `json:"name" cborgen:"name"`
 }
 
-// SyncSubscribeRepos_Migrate is a "migrate" in the com.atproto.sync.subscribeRepos schema.
-//
-// DEPRECATED -- Use #account event instead
-type SyncSubscribeRepos_Migrate struct {
-	Did       string  `json:"did" cborgen:"did"`
-	MigrateTo *string `json:"migrateTo" cborgen:"migrateTo"`
-	Seq       int64   `json:"seq" cborgen:"seq"`
-	Time      string  `json:"time" cborgen:"time"`
-}
-
 // SyncSubscribeRepos_RepoOp is a "repoOp" in the com.atproto.sync.subscribeRepos schema.
 //
 // A repo operation, ie a mutation of a single record.
···
 	// time: Timestamp of when this message was originally broadcast.
 	Time string `json:"time" cborgen:"time"`
 }
-
-// SyncSubscribeRepos_Tombstone is a "tombstone" in the com.atproto.sync.subscribeRepos schema.
-//
-// DEPRECATED -- Use #account event instead
-type SyncSubscribeRepos_Tombstone struct {
-	Did  string `json:"did" cborgen:"did"`
-	Seq  int64  `json:"seq" cborgen:"seq"`
-	Time string `json:"time" cborgen:"time"`
-}

api/bsky/feeddefs.go

···
 	Post        *FeedDefs_PostView            `json:"post" cborgen:"post"`
 	Reason      *FeedDefs_FeedViewPost_Reason `json:"reason,omitempty" cborgen:"reason,omitempty"`
 	Reply       *FeedDefs_ReplyRef            `json:"reply,omitempty" cborgen:"reply,omitempty"`
+	// reqId: Unique identifier per request that may be passed back alongside interactions.
+	ReqId *string `json:"reqId,omitempty" cborgen:"reqId,omitempty"`
 }
 
 type FeedDefs_FeedViewPost_Reason struct {
···
 	// feedContext: Context on a feed item that was originally supplied by the feed generator on getFeedSkeleton.
 	FeedContext *string `json:"feedContext,omitempty" cborgen:"feedContext,omitempty"`
 	Item        *string `json:"item,omitempty" cborgen:"item,omitempty"`
+	// reqId: Unique identifier per request that may be passed back alongside interactions.
+	ReqId *string `json:"reqId,omitempty" cborgen:"reqId,omitempty"`
 }
 
 // FeedDefs_NotFoundPost is a "notFoundPost" in the app.bsky.feed.defs schema.
···
 type FeedDefs_ReasonRepost struct {
 	LexiconTypeID string                      `json:"$type,const=app.bsky.feed.defs#reasonRepost" cborgen:"$type,const=app.bsky.feed.defs#reasonRepost"`
 	By            *ActorDefs_ProfileViewBasic `json:"by" cborgen:"by"`
+	Cid           *string                     `json:"cid,omitempty" cborgen:"cid,omitempty"`
 	IndexedAt     string                      `json:"indexedAt" cborgen:"indexedAt"`
+	Uri           *string                     `json:"uri,omitempty" cborgen:"uri,omitempty"`
 }
 
 // FeedDefs_ReplyRef is a "replyRef" in the app.bsky.feed.defs schema.

api/bsky/feedgetFeedSkeleton.go

···
 type FeedGetFeedSkeleton_Output struct {
 	Cursor *string                      `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
 	Feed   []*FeedDefs_SkeletonFeedPost `json:"feed" cborgen:"feed"`
+	// reqId: Unique identifier per request that may be passed back alongside interactions.
+	ReqId *string `json:"reqId,omitempty" cborgen:"reqId,omitempty"`
 }
 
 // FeedGetFeedSkeleton calls the XRPC method "app.bsky.feed.getFeedSkeleton".

api/bsky/feedlike.go

···
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.like" cborgen:"$type,const=app.bsky.feed.like"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`
 	Subject       *comatprototypes.RepoStrongRef `json:"subject" cborgen:"subject"`
+	Via           *comatprototypes.RepoStrongRef `json:"via,omitempty" cborgen:"via,omitempty"`
 }

api/bsky/feedrepost.go

···
 	LexiconTypeID string                         `json:"$type,const=app.bsky.feed.repost" cborgen:"$type,const=app.bsky.feed.repost"`
 	CreatedAt     string                         `json:"createdAt" cborgen:"createdAt"`
 	Subject       *comatprototypes.RepoStrongRef `json:"subject" cborgen:"subject"`
+	Via           *comatprototypes.RepoStrongRef `json:"via,omitempty" cborgen:"via,omitempty"`
 }

api/bsky/notificationlistNotifications.go

···
 	IndexedAt string                             `json:"indexedAt" cborgen:"indexedAt"`
 	IsRead    bool                               `json:"isRead" cborgen:"isRead"`
 	Labels    []*comatprototypes.LabelDefs_Label `json:"labels,omitempty" cborgen:"labels,omitempty"`
-	// reason: Expected values are 'like', 'repost', 'follow', 'mention', 'reply', 'quote', 'starterpack-joined', 'verified', and 'unverified'.
+	// reason: The reason why this notification was delivered - e.g. your post was liked, or you received a new follower.
 	Reason        string                   `json:"reason" cborgen:"reason"`
 	ReasonSubject *string                  `json:"reasonSubject,omitempty" cborgen:"reasonSubject,omitempty"`
 	Record        *util.LexiconTypeDecoder `json:"record" cborgen:"record"`

api/bsky/unspeccedgetConfig.go

···
 	"github.com/bluesky-social/indigo/xrpc"
 )
 
+// UnspeccedGetConfig_LiveNowConfig is a "liveNowConfig" in the app.bsky.unspecced.getConfig schema.
+type UnspeccedGetConfig_LiveNowConfig struct {
+	Did     string   `json:"did" cborgen:"did"`
+	Domains []string `json:"domains" cborgen:"domains"`
+}
+
 // UnspeccedGetConfig_Output is the output of a app.bsky.unspecced.getConfig call.
 type UnspeccedGetConfig_Output struct {
-	CheckEmailConfirmed *bool `json:"checkEmailConfirmed,omitempty" cborgen:"checkEmailConfirmed,omitempty"`
+	CheckEmailConfirmed *bool                               `json:"checkEmailConfirmed,omitempty" cborgen:"checkEmailConfirmed,omitempty"`
+	LiveNow             []*UnspeccedGetConfig_LiveNowConfig `json:"liveNow,omitempty" cborgen:"liveNow,omitempty"`
 }
 
 // UnspeccedGetConfig calls the XRPC method "app.bsky.unspecced.getConfig".

api/ozone/moderationdefs.go

···
 //
 // Detailed view of a subject. For record subjects, the author's repo and profile will be returned.
 type ModerationDefs_SubjectView struct {
-	//Profile *ModerationDefs_SubjectView_Profile `json:"profile,omitempty" cborgen:"profile,omitempty"`
 	Record  *ModerationDefs_RecordViewDetail  `json:"record,omitempty" cborgen:"record,omitempty"`
 	Repo    *ModerationDefs_RepoViewDetail    `json:"repo,omitempty" cborgen:"repo,omitempty"`
 	Status  *ModerationDefs_SubjectStatusView `json:"status,omitempty" cborgen:"status,omitempty"`

api/ozone/verificationdefs.go

···
 	// handle: Handle of the subject the verification applies to at the moment of verifying, which might not be the same at the time of viewing. The verification is only valid if the current handle matches the one at the time of verifying.
 	Handle string `json:"handle" cborgen:"handle"`
 	// issuer: The user who issued this verification.
-	Issuer string `json:"issuer" cborgen:"issuer"`
-	//IssuerProfile *VerificationDefs_VerificationView_IssuerProfile `json:"issuerProfile,omitempty" cborgen:"issuerProfile,omitempty"`
-	//IssuerRepo    *VerificationDefs_VerificationView_IssuerRepo    `json:"issuerRepo,omitempty" cborgen:"issuerRepo,omitempty"`
+	Issuer     string                                        `json:"issuer" cborgen:"issuer"`
+	IssuerRepo *VerificationDefs_VerificationView_IssuerRepo `json:"issuerRepo,omitempty" cborgen:"issuerRepo,omitempty"`
 	// revokeReason: Describes the reason for revocation, also indicating that the verification is no longer valid.
 	RevokeReason *string `json:"revokeReason,omitempty" cborgen:"revokeReason,omitempty"`
 	// revokedAt: Timestamp when the verification was revoked.
···
 	// revokedBy: The user who revoked this verification.
 	RevokedBy *string `json:"revokedBy,omitempty" cborgen:"revokedBy,omitempty"`
 	// subject: The subject of the verification.
-	Subject string `json:"subject" cborgen:"subject"`
-	//SubjectProfile *VerificationDefs_VerificationView_SubjectProfile `json:"subjectProfile,omitempty" cborgen:"subjectProfile,omitempty"`
-	//SubjectRepo    *VerificationDefs_VerificationView_SubjectRepo    `json:"subjectRepo,omitempty" cborgen:"subjectRepo,omitempty"`
+	Subject     string                                         `json:"subject" cborgen:"subject"`
+	SubjectRepo *VerificationDefs_VerificationView_SubjectRepo `json:"subjectRepo,omitempty" cborgen:"subjectRepo,omitempty"`
 	// uri: The AT-URI of the verification record.
 	Uri string `json:"uri" cborgen:"uri"`
 }

atproto/crypto/jwk.go

···
+package crypto
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"math/big"
+
+	secp256k1 "gitlab.com/yawning/secp256k1-voi"
+	secp256k1secec "gitlab.com/yawning/secp256k1-voi/secec"
+)
+
+// Representation of a JSON Web Key (JWK), as relevant to the keys supported by this package.
+//
+// Expected to be marshalled/unmarshalled as JSON.
+type JWK struct {
+	KeyType string  `json:"kty"`
+	Curve   string  `json:"crv"`
+	X       string  `json:"x"` // base64url, no padding
+	Y       string  `json:"y"` // base64url, no padding
+	Use     string  `json:"use,omitempty"`
+	KeyID   *string `json:"kid,omitempty"`
+}
+
+// Loads a [PublicKey] from JWK (serialized as JSON bytes)
+func ParsePublicJWKBytes(jwkBytes []byte) (PublicKey, error) {
+	var jwk JWK
+	if err := json.Unmarshal(jwkBytes, &jwk); err != nil {
+		return nil, fmt.Errorf("parsing JWK JSON: %w", err)
+	}
+	return ParsePublicJWK(jwk)
+}
+
+// Loads a [PublicKey] from JWK struct.
+func ParsePublicJWK(jwk JWK) (PublicKey, error) {
+
+	if jwk.KeyType != "EC" {
+		return nil, fmt.Errorf("unsupported JWK key type: %s", jwk.KeyType)
+	}
+
+	// base64url with no encoding
+	xbuf, err := base64.RawURLEncoding.DecodeString(jwk.X)
+	if err != nil {
+		return nil, fmt.Errorf("invalid JWK base64 encoding: %w", err)
+	}
+	ybuf, err := base64.RawURLEncoding.DecodeString(jwk.Y)
+	if err != nil {
+		return nil, fmt.Errorf("invalid JWK base64 encoding: %w", err)
+	}
+
+	switch jwk.Curve {
+	case "P-256":
+		curve := elliptic.P256()
+
+		var x, y big.Int
+		x.SetBytes(xbuf)
+		y.SetBytes(ybuf)
+
+		if !curve.Params().IsOnCurve(&x, &y) {
+			return nil, fmt.Errorf("invalid P-256 public key (not on curve)")
+		}
+		pubECDSA := &ecdsa.PublicKey{
+			Curve: curve,
+			X:     &x,
+			Y:     &y,
+		}
+		pub := PublicKeyP256{pubP256: *pubECDSA}
+		err := pub.checkCurve()
+		if err != nil {
+			return nil, err
+		}
+		return &pub, nil
+	case "secp256k1": // K-256
+		if len(xbuf) != 32 || len(ybuf) != 32 {
+			return nil, fmt.Errorf("invalid K-256 coordinates")
+		}
+		xarr := ([32]byte)(xbuf[:32])
+		yarr := ([32]byte)(ybuf[:32])
+		p, err := secp256k1.NewPointFromCoords(&xarr, &yarr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid K-256 coordinates: %w", err)
+		}
+		pubK, err := secp256k1secec.NewPublicKeyFromPoint(p)
+		if err != nil {
+			return nil, fmt.Errorf("invalid K-256/secp256k1 public key: %w", err)
+		}
+		pub := PublicKeyK256{pubK256: pubK}
+		err = pub.ensureBytes()
+		if err != nil {
+			return nil, err
+		}
+		return &pub, nil
+	default:
+		return nil, fmt.Errorf("unsupported JWK cryptography: %s", jwk.Curve)
+	}
+}
+
+func (k *PublicKeyP256) JWK() (*JWK, error) {
+	jwk := JWK{
+		KeyType: "EC",
+		Curve:   "P-256",
+		X:       base64.RawURLEncoding.EncodeToString(k.pubP256.X.Bytes()),
+		Y:       base64.RawURLEncoding.EncodeToString(k.pubP256.Y.Bytes()),
+	}
+	return &jwk, nil
+}
+
+func (k *PublicKeyK256) JWK() (*JWK, error) {
+	raw := k.UncompressedBytes()
+	if len(raw) != 65 {
+		return nil, fmt.Errorf("unexpected K-256 bytes size")
+	}
+	xbytes := raw[1:33]
+	ybytes := raw[33:65]
+	jwk := JWK{
+		KeyType: "EC",
+		Curve:   "secp256k1",
+		X:       base64.RawURLEncoding.EncodeToString(xbytes),
+		Y:       base64.RawURLEncoding.EncodeToString(ybytes),
+	}
+	return &jwk, nil
+}

atproto/crypto/jwk_test.go

···
+package crypto
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParseJWK(t *testing.T) {
+	assert := assert.New(t)
+
+	jwkTestFixtures := []string{
+		// https://datatracker.ietf.org/doc/html/rfc7517#appendix-A.1
+		`{
+			"kty":"EC",
+          	"crv":"P-256",
+          	"x":"MKBCTNIcKUSDii11ySs3526iDZ8AiTo7Tu6KPAqv7D4",
+          	"y":"4Etl6SRW2YiLUrN5vfvVHuhp7x8PxltmWWlbbM4IFyM",
+          	"d":"870MB6gfuTJ4HtUnUvYMyJpr5eUZNP4Bk43bVdj3eAE",
+          	"use":"enc",
+          	"kid":"1"
+      	}`,
+		// https://openid.net/specs/draft-jones-json-web-key-03.html; with kty in addition to alg
+		`{
+			"alg":"EC",
+			"kty":"EC",
+			"crv":"P-256",
+			"x":"MKBCTNIcKUSDii11ySs3526iDZ8AiTo7Tu6KPAqv7D4",
+			"y":"4Etl6SRW2YiLUrN5vfvVHuhp7x8PxltmWWlbbM4IFyM",
+			"use":"enc",
+			"kid":"1"
+		}`,
+		// https://w3c-ccg.github.io/lds-ecdsa-secp256k1-2019/; with kty in addition to alg
+		`{
+    		"alg": "EC",
+    		"kty": "EC",
+    		"crv": "secp256k1",
+    		"kid": "JUvpllMEYUZ2joO59UNui_XYDqxVqiFLLAJ8klWuPBw",
+    		"x": "dWCvM4fTdeM0KmloF57zxtBPXTOythHPMm1HCLrdd3A",
+    		"y": "36uMVGM7hnw-N6GnjFcihWE3SkrhMLzzLCdPMXPEXlA"
+  		}`,
+	}
+
+	for _, jwkBytes := range jwkTestFixtures {
+		_, err := ParsePublicJWKBytes([]byte(jwkBytes))
+		assert.NoError(err)
+	}
+}
+
+func TestP256GenJWK(t *testing.T) {
+	assert := assert.New(t)
+
+	priv, err := GeneratePrivateKeyP256()
+	if err != nil {
+		t.Fatal(err)
+	}
+	pub, err := priv.PublicKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pk, ok := pub.(*PublicKeyP256)
+	if !ok {
+		t.Fatal()
+	}
+	jwk, err := pk.JWK()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = ParsePublicJWK(*jwk)
+	assert.NoError(err)
+}
+
+func TestK256GenJWK(t *testing.T) {
+	assert := assert.New(t)
+
+	priv, err := GeneratePrivateKeyK256()
+	if err != nil {
+		t.Fatal(err)
+	}
+	pub, err := priv.PublicKey()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	pk, ok := pub.(*PublicKeyK256)
+	if !ok {
+		t.Fatal()
+	}
+	jwk, err := pk.JWK()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = ParsePublicJWK(*jwk)
+	assert.NoError(err)
+}

atproto/crypto/keys.go

···
 	// No ASN.1 or other enclosing structure is applied to the bytes.
 	Bytes() []byte
 
-	// NOTE: should Multibase() (string, error) be part of this interface? Probably.
+	// String serialization of the key bytes in "Multibase" format.
+	Multibase() string
 }
 
 // Common interface for all the supported atproto cryptographic systems.
···
 	// For systems with no compressed/uncompressed distinction, returns the same
 	// value as Bytes().
 	UncompressedBytes() []byte
+
+	// Serialization as JWK struct (which can be marshalled to JSON)
+	JWK() (*JWK, error)
 }
 
 var ErrInvalidSignature = errors.New("crytographic signature invalid")

atproto/crypto/keys_test.go

···
 	assert.NoError(err)
 	_, ok := privP256FromMB.(*PrivateKeyP256)
 	assert.True(ok)
+	assert.Equal(privP256MB, privP256FromMB.Multibase())
 
 	privK256FromMB, err := ParsePrivateMultibase(privK256MB)
 	assert.NoError(err)
 	_, ok = privK256FromMB.(*PrivateKeyK256)
 	assert.True(ok)
+	assert.Equal(privK256MB, privK256FromMB.Multibase())
 }

atproto/data/parse.go

···
 
 func parseFloat(f float64) (int64, error) {
 	if f != float64(int64(f)) {
-		return 0, fmt.Errorf("number was is not a safe integer: %f", f)
+		return 0, fmt.Errorf("number is not a safe integer: %f", f)
 	}
 	return int64(f), nil
 }

bgs/bgs.go

···
 
 		repoCommitsResultCounter.WithLabelValues(host.Host, "ok").Inc()
 		return nil
-	case env.RepoHandle != nil:
-		bgs.log.Info("bgs got repo handle event", "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
-		// Flush any cached DID documents for this user
-		bgs.didr.FlushCacheFor(env.RepoHandle.Did)
-
-		// TODO: ignoring the data in the message and just going out to the DID doc
-		act, err := bgs.createExternalUser(ctx, env.RepoHandle.Did)
-		if err != nil {
-			return err
-		}
-
-		if act.Handle.String != env.RepoHandle.Handle {
-			bgs.log.Warn("handle update did not update handle to asserted value", "did", env.RepoHandle.Did, "expected", env.RepoHandle.Handle, "actual", act.Handle)
-		}
-
-		// TODO: Update the ReposHandle event type to include "verified" or something
-
-		// Broadcast the handle update to all consumers
-		err = bgs.events.AddEvent(ctx, &events.XRPCStreamEvent{
-			RepoHandle: &comatproto.SyncSubscribeRepos_Handle{
-				Did:    env.RepoHandle.Did,
-				Handle: env.RepoHandle.Handle,
-				Time:   env.RepoHandle.Time,
-			},
-		})
-		if err != nil {
-			bgs.log.Error("failed to broadcast RepoHandle event", "error", err, "did", env.RepoHandle.Did, "handle", env.RepoHandle.Handle)
-			return fmt.Errorf("failed to broadcast RepoHandle event: %w", err)
-		}
-
-		return nil
 	case env.RepoIdentity != nil:
 		bgs.log.Info("bgs got identity event", "did", env.RepoIdentity.Did)
 		// Flush any cached DID documents for this user
···
 		}
 
 		return nil
-	case env.RepoMigrate != nil:
-		if _, err := bgs.createExternalUser(ctx, env.RepoMigrate.Did); err != nil {
-			return err
-		}
-
-		return nil
-	case env.RepoTombstone != nil:
-		if err := bgs.handleRepoTombstone(ctx, host, env.RepoTombstone); err != nil {
-			return err
-		}
-
-		return nil
 	default:
 		return fmt.Errorf("invalid fed event")
 	}
-}
-
-func (bgs *BGS) handleRepoTombstone(ctx context.Context, pds *models.PDS, evt *atproto.SyncSubscribeRepos_Tombstone) error {
-	u, err := bgs.lookupUserByDid(ctx, evt.Did)
-	if err != nil {
-		return err
-	}
-
-	if u.PDS != pds.ID {
-		return fmt.Errorf("unauthoritative tombstone event from %s for %s", pds.Host, evt.Did)
-	}
-
-	if err := bgs.db.Model(&User{}).Where("id = ?", u.ID).UpdateColumns(map[string]any{
-		"tombstoned": true,
-		"handle":     nil,
-	}).Error; err != nil {
-		return err
-	}
-	u.SetTombstoned(true)
-
-	if err := bgs.db.Model(&models.ActorInfo{}).Where("uid = ?", u.ID).UpdateColumns(map[string]any{
-		"handle": nil,
-	}).Error; err != nil {
-		return err
-	}
-
-	// delete data from carstore
-	if err := bgs.repoman.TakeDownRepo(ctx, u.ID); err != nil {
-		// don't let a failure here prevent us from propagating this event
-		bgs.log.Error("failed to delete user data from carstore", "err", err)
-	}
-
-	return bgs.events.AddEvent(ctx, &events.XRPCStreamEvent{
-		RepoTombstone: evt,
-	})
 }
 
 // TODO: rename? This also updates users, and 'external' is an old phrasing

bgs/fedmgr.go

···
 
 			return nil
 		},
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			log.Info("got remote handle update event", "pdsHost", host.Host, "did", evt.Did, "handle", evt.Handle)
-			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
-				RepoHandle: evt,
-			}); err != nil {
-				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
-			}
-			*lastCursor = evt.Seq
-
-			if err := s.updateCursor(sub, *lastCursor); err != nil {
-				return fmt.Errorf("updating cursor: %w", err)
-			}
-
-			return nil
-		},
-		RepoMigrate: func(evt *comatproto.SyncSubscribeRepos_Migrate) error {
-			log.Info("got remote repo migrate event", "pdsHost", host.Host, "did", evt.Did, "migrateTo", evt.MigrateTo)
-			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
-				RepoMigrate: evt,
-			}); err != nil {
-				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
-			}
-			*lastCursor = evt.Seq
-
-			if err := s.updateCursor(sub, *lastCursor); err != nil {
-				return fmt.Errorf("updating cursor: %w", err)
-			}
-
-			return nil
-		},
-		RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error {
-			log.Info("got remote repo tombstone event", "pdsHost", host.Host, "did", evt.Did)
-			if err := s.cb(context.TODO(), host, &events.XRPCStreamEvent{
-				RepoTombstone: evt,
-			}); err != nil {
-				log.Error("failed handling event", "host", host.Host, "seq", evt.Seq, "err", err)
-			}
-			*lastCursor = evt.Seq
-
-			if err := s.updateCursor(sub, *lastCursor); err != nil {
-				return fmt.Errorf("updating cursor: %w", err)
-			}
-
-			return nil
-		},
 		RepoInfo: func(info *comatproto.SyncSubscribeRepos_Info) error {
 			log.Info("info event", "name", info.Name, "message", info.Message, "pdsHost", host.Host)
 			return nil

cmd/collectiondir/serve.go

···
 	"context"
 	"encoding/csv"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log/slog"
 	"net"
 	"net/http"
+	_ "net/http/pprof"
 	"net/url"
 	"os"
 	"os/signal"
···
 	if err != nil {
 		return fmt.Errorf("lru init, %w", err)
 	}
-	cs.wg.Add(1)
-	go cs.ingestReceiver()
 	cs.log = log
 	cs.ctx = cctx.Context
 	cs.AdminToken = cctx.String("admin-token")
 	cs.ExepctedAuthHeader = "Bearer " + cs.AdminToken
+	cs.wg.Add(1)
+	go cs.ingestReceiver()
 	pebblePath := cctx.String("pebble")
 	cs.pcd = &PebbleCollectionDirectory{
 		log: cs.log,
···
 		}
 	}
 	cs.statsCacheFresh.L = &cs.statsCacheLock
-	errchan := make(chan error, 3)
-	apiAddr := cctx.String("api-listen")
+
+	apiServerEcho, err := cs.createApiServer(cctx.Context, cctx.String("api-listen"))
+	if err != nil {
+		return err
+	}
 	cs.wg.Add(1)
-	go func() {
-		errchan <- cs.StartApiServer(cctx.Context, apiAddr)
-	}()
-	metricsAddr := cctx.String("metrics-listen")
+	go func() { cs.StartApiServer(cctx.Context, apiServerEcho) }()
+
+	cs.createMetricsServer(cctx.String("metrics-listen"))
 	cs.wg.Add(1)
-	go func() {
-		errchan <- cs.StartMetricsServer(cctx.Context, metricsAddr)
-	}()
+	go func() { cs.StartMetricsServer(cctx.Context) }()
 
 	upstream := cctx.String("upstream")
 	if upstream != "" {
···
 		go cs.handleFirehose(fhevents)
 	}
 
-	select {
-	case <-signals:
-		log.Info("received shutdown signal")
-		go errchanlog(cs.log, "server error", errchan)
-		return cs.Shutdown()
-	case err := <-errchan:
-		if err != nil {
-			log.Error("server error", "err", err)
-			go errchanlog(cs.log, "server error", errchan)
-			return cs.Shutdown()
-		}
-	}
-	return nil
+	<-signals
+	log.Info("received shutdown signal")
+	return cs.Shutdown()
 }
 
 func (cs *collectionServer) openDau() error {
···
 	return nil
 }
 
-func errchanlog(log *slog.Logger, msg string, errchan <-chan error) {
-	for err := range errchan {
-		log.Error(msg, "err", err)
-	}
-}
-
 func (cs *collectionServer) Shutdown() error {
 	close(cs.shutdown)
-	go func() {
+
+	func() {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+		defer cancel()
+
 		cs.log.Info("metrics shutdown start")
-		sherr := cs.metricsServer.Shutdown(context.Background())
+		sherr := cs.metricsServer.Shutdown(ctx)
 		cs.log.Info("metrics shutdown", "err", sherr)
 	}()
-	cs.log.Info("api shutdown start...")
-	err := cs.apiServer.Shutdown(context.Background())
-	cs.log.Info("api shutdown, thread wait...", "err", err)
-	cs.wg.Wait()
+
+	func() {
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+
+		cs.log.Info("api shutdown start...")
+		err := cs.apiServer.Shutdown(ctx)
+		cs.log.Info("api shutdown, thread wait...", "err", err)
+	}()
+
 	cs.log.Info("threads done, db close...")
-	ee := cs.pcd.Close()
-	if ee != nil {
-		cs.log.Error("failed to shutdown pebble", "err", ee)
+	err := cs.pcd.Close()
+	if err != nil {
+		cs.log.Error("failed to shutdown pebble", "err", err)
 	}
 	cs.log.Info("db done. done.")
+	cs.wg.Wait()
 	return err
 }
 
···
 	}
 }
 
-func (cs *collectionServer) StartMetricsServer(ctx context.Context, addr string) error {
-	defer cs.wg.Done()
-	defer cs.log.Info("metrics server exit")
+func (cs *collectionServer) createMetricsServer(addr string) {
+	e := echo.New()
+	e.GET("/metrics", echo.WrapHandler(promhttp.Handler()))
+	e.Any("/debug/pprof/*", echo.WrapHandler(http.DefaultServeMux))
+
 	cs.metricsServer = &http.Server{
 		Addr:    addr,
-		Handler: promhttp.Handler(),
+		Handler: e,
 	}
-	return cs.metricsServer.ListenAndServe()
 }
 
-func (cs *collectionServer) StartApiServer(ctx context.Context, addr string) error {
+func (cs *collectionServer) StartMetricsServer(ctx context.Context) {
 	defer cs.wg.Done()
-	defer cs.log.Info("api server exit")
+	defer cs.log.Info("metrics server exit")
+
+	err := cs.metricsServer.ListenAndServe()
+	if err != nil && !errors.Is(err, http.ErrServerClosed) {
+		slog.Error("error in metrics server", "err", err)
+		os.Exit(1)
+	}
+}
+
+func (cs *collectionServer) createApiServer(ctx context.Context, addr string) (*echo.Echo, error) {
 	var lc net.ListenConfig
 	li, err := lc.Listen(ctx, "tcp", addr)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	e := echo.New()
 	e.HideBanner = true
···
 		Handler: e,
 	}
 	cs.apiServer = srv
-	return srv.Serve(li)
+	return e, nil
+}
+
+func (cs *collectionServer) StartApiServer(ctx context.Context, e *echo.Echo) {
+	defer cs.wg.Done()
+	defer cs.log.Info("api server exit")
+	err := cs.apiServer.Serve(e.Listener)
+	if err != nil && !errors.Is(err, http.ErrServerClosed) {
+		slog.Error("error in api server", "err", err)
+		os.Exit(1)
+	}
 }
 
 const statsCacheDuration = time.Second * 300

cmd/goat/firehose.go

···
 			}
 			return nil
 		},
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			if gfc.VerifyBasic {
-				slog.Info("deprecated event type", "eventType", "handle", "did", evt.Did, "seq", evt.Seq)
-			}
-			return nil
-		},
-		RepoMigrate: func(evt *comatproto.SyncSubscribeRepos_Migrate) error {
-			if gfc.VerifyBasic {
-				slog.Info("deprecated event type", "eventType", "migrate", "did", evt.Did, "seq", evt.Seq)
-			}
-			return nil
-		},
-		RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error {
-			if gfc.VerifyBasic {
-				slog.Info("deprecated event type", "eventType", "handle", "did", evt.Did, "seq", evt.Seq)
-			}
-			return nil
-		},
 	}
 
 	scheduler := parallel.NewScheduler(

cmd/gosky/debug.go

···
 
 				return nil
 			},
-			RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-				fmt.Printf("\rChecking seq: %d      ", evt.Seq)
-				if lastSeq > 0 && evt.Seq != lastSeq+1 {
-					fmt.Println("Gap in sequence numbers: ", lastSeq, evt.Seq)
-				}
-				lastSeq = evt.Seq
-				return nil
-			},
-			RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error {
-				fmt.Printf("\rChecking seq: %d      ", evt.Seq)
-				if lastSeq > 0 && evt.Seq != lastSeq+1 {
-					fmt.Println("Gap in sequence numbers: ", lastSeq, evt.Seq)
-				}
-				lastSeq = evt.Seq
-				return nil
-			},
 			RepoInfo: func(evt *comatproto.SyncSubscribeRepos_Info) error {
 				return nil
 			},

cmd/gosky/main.go

···
 
 				return nil
 			},
-			RepoMigrate: func(migrate *comatproto.SyncSubscribeRepos_Migrate) error {
-				if jsonfmt {
-					b, err := json.Marshal(migrate)
-					if err != nil {
-						return err
-					}
-					fmt.Println(string(b))
-				} else {
-					fmt.Printf("(%d) RepoMigrate: %s moving to: %s\n", migrate.Seq, migrate.Did, *migrate.MigrateTo)
-				}
-
-				return nil
-			},
-			RepoHandle: func(handle *comatproto.SyncSubscribeRepos_Handle) error {
-				if jsonfmt {
-					b, err := json.Marshal(handle)
-					if err != nil {
-						return err
-					}
-					fmt.Println(string(b))
-				} else {
-					fmt.Printf("(%d) RepoHandle: %s (changed to: %s)\n", handle.Seq, handle.Did, handle.Handle)
-				}
-
-				return nil
-
-			},
 			RepoInfo: func(info *comatproto.SyncSubscribeRepos_Info) error {
 				if jsonfmt {
 					b, err := json.Marshal(info)
···
 				}
 
 				return nil
-			},
-			RepoTombstone: func(tomb *comatproto.SyncSubscribeRepos_Tombstone) error {
-				if jsonfmt {
-					b, err := json.Marshal(tomb)
-					if err != nil {
-						return err
-					}
-					fmt.Println(string(b))
-				} else {
-					fmt.Printf("(%d) Tombstone: %s\n", tomb.Seq, tomb.Did)
-				}
-
-				return nil
-
 			},
 			// TODO: all the other event types
 			Error: func(errf *events.ErrorFrame) error {

cmd/gosky/streamdiff.go

···
 		return "ERROR"
 	case evt.RepoCommit != nil:
 		return "#commit"
-	case evt.RepoHandle != nil:
-		return "#handle"
 	case evt.RepoInfo != nil:
 		return "#info"
-	case evt.RepoMigrate != nil:
-		return "#migrate"
-	case evt.RepoTombstone != nil:
-		return "#tombstone"
 	default:
 		return "unknown"
 	}
···
 			if sameCommit(evt.RepoCommit, oe.RepoCommit) {
 				return i
 			}
-		case evt.RepoHandle != nil:
-			panic("not handling handle updates yet")
-		case evt.RepoMigrate != nil:
-			panic("not handling repo migrates yet")
 		default:
 			panic("unhandled event type: " + evtop)
 		}

cmd/lexgen/main.go

···
 		&cli.StringFlag{
 			Name: "outdir",
 		},
-		&cli.StringFlag{
-			Name: "prefix",
-		},
 		&cli.BoolFlag{
 			Name: "gen-server",
 		},
···
 		},
 		&cli.StringSliceFlag{
 			Name: "types-import",
+		},
+		&cli.StringSliceFlag{
+			Name: "external-lexicons",
 		},
 		&cli.StringFlag{
 			Name:  "package",
···
 			schemas = append(schemas, s)
 		}
 
+		externalPaths, err := expandArgs(cctx.StringSlice("external-lexicons"))
+		if err != nil {
+			return err
+		}
+		var externalSchemas []*lex.Schema
+		for _, arg := range externalPaths {
+			s, err := lex.ReadSchema(arg)
+			if err != nil {
+				return fmt.Errorf("failed to read file %q: %w", arg, err)
+			}
+
+			externalSchemas = append(externalSchemas, s)
+		}
+
 		buildLiteral := cctx.String("build")
 		buildPath := cctx.String("build-file")
 		var packages []lex.Package
···
 			if outdir == "" {
 				return fmt.Errorf("must specify output directory (--outdir)")
 			}
-			defmap := lex.BuildExtDefMap(schemas, packages)
+			defmap := lex.BuildExtDefMap(append(schemas, externalSchemas...), packages)
 			_ = defmap
 
 			paths := cctx.StringSlice("types-import")
···
 			}
 
 		} else {
-			return lex.Run(schemas, packages)
+			return lex.Run(schemas, externalSchemas, packages)
 		}
 
 		return nil

cmd/relay/handlers.go

···
 	}
 	go s.ForwardSiblingRequest(c, b)
 
-	return s.relay.SubscribeToHost(ctx, hostname, noSSL, false)
+	return s.relay.SubscribeToHost(ctx, hostname, noSSL, admin)
 }
 
 func (s *Service) handleComAtprotoSyncListHosts(c echo.Context, cursor int64, limit int) (*comatproto.SyncListHosts_Output, error) {

cmd/relay/relay/ingest.go

···
 	case evt.RepoAccount != nil:
 		//repoAccountReceivedCounter.WithLabelValues(hostname).Add(1)
 		return r.processAccountEvent(ctx, evt.RepoAccount, hostname, hostID)
-	case evt.RepoHandle != nil: // DEPRECATED
-		eventsWarningsCounter.WithLabelValues(hostname, "handle").Add(1)
-		return nil
-	case evt.RepoMigrate != nil: // DEPRECATED
-		eventsWarningsCounter.WithLabelValues(hostname, "migrate").Add(1)
-		return nil
-	case evt.RepoTombstone != nil: // DEPRECATED
-		eventsWarningsCounter.WithLabelValues(hostname, "tombstone").Add(1)
-		return nil
 	default:
 		return fmt.Errorf("unhandled repo stream event type")
 	}

cmd/relay/relay/slurper.go

···
 			s.logger.Debug("info event", "name", info.Name, "message", info.Message, "host", sub.Hostname)
 			return nil
 		},
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error { // DEPRECATED
-			logger := s.logger.With("host", sub.Hostname, "did", evt.Did, "seq", evt.Seq, "eventType", "handle")
-			logger.Debug("got remote handle update event", "handle", evt.Handle)
-			if err := s.processCallback(context.Background(), &stream.XRPCStreamEvent{RepoHandle: evt}, sub.Hostname, sub.HostID); err != nil {
-				logger.Error("failed handling event", "err", err)
-			}
-			sub.UpdateSeq()
-			return nil
-		},
-		RepoMigrate: func(evt *comatproto.SyncSubscribeRepos_Migrate) error { // DEPRECATED
-			logger := s.logger.With("host", sub.Hostname, "did", evt.Did, "seq", evt.Seq, "eventType", "migrate")
-			logger.Debug("got remote repo migrate event", "migrateTo", evt.MigrateTo)
-			if err := s.processCallback(context.Background(), &stream.XRPCStreamEvent{RepoMigrate: evt}, sub.Hostname, sub.HostID); err != nil {
-				logger.Error("failed handling event", "err", err)
-			}
-			sub.UpdateSeq()
-			return nil
-		},
-		RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error { // DEPRECATED
-			logger := s.logger.With("host", sub.Hostname, "did", evt.Did, "seq", evt.Seq, "eventType", "tombstone")
-			logger.Debug("got remote repo tombstone event")
-			if err := s.processCallback(context.Background(), &stream.XRPCStreamEvent{RepoTombstone: evt}, sub.Hostname, sub.HostID); err != nil {
-				logger.Error("failed handling event", "err", err)
-			}
-			sub.UpdateSeq()
-			return nil
-		},
 	}
 
 	limiters := []*slidingwindow.Limiter{

cmd/relay/stream/consumer.go

···
 const MaxMessageBytes = 5_000_000
 
 type RepoStreamCallbacks struct {
-	RepoCommit    func(evt *comatproto.SyncSubscribeRepos_Commit) error
-	RepoSync      func(evt *comatproto.SyncSubscribeRepos_Sync) error
-	RepoHandle    func(evt *comatproto.SyncSubscribeRepos_Handle) error
-	RepoIdentity  func(evt *comatproto.SyncSubscribeRepos_Identity) error
-	RepoAccount   func(evt *comatproto.SyncSubscribeRepos_Account) error
-	RepoInfo      func(evt *comatproto.SyncSubscribeRepos_Info) error
-	RepoMigrate   func(evt *comatproto.SyncSubscribeRepos_Migrate) error
-	RepoTombstone func(evt *comatproto.SyncSubscribeRepos_Tombstone) error
-	LabelLabels   func(evt *comatproto.LabelSubscribeLabels_Labels) error
-	LabelInfo     func(evt *comatproto.LabelSubscribeLabels_Info) error
-	Error         func(evt *ErrorFrame) error
+	RepoCommit   func(evt *comatproto.SyncSubscribeRepos_Commit) error
+	RepoSync     func(evt *comatproto.SyncSubscribeRepos_Sync) error
+	RepoIdentity func(evt *comatproto.SyncSubscribeRepos_Identity) error
+	RepoAccount  func(evt *comatproto.SyncSubscribeRepos_Account) error
+	RepoInfo     func(evt *comatproto.SyncSubscribeRepos_Info) error
+	LabelLabels  func(evt *comatproto.LabelSubscribeLabels_Labels) error
+	LabelInfo    func(evt *comatproto.LabelSubscribeLabels_Info) error
+	Error        func(evt *ErrorFrame) error
 }
 
 func (rsc *RepoStreamCallbacks) EventHandler(ctx context.Context, xev *XRPCStreamEvent) error {
···
 		return rsc.RepoCommit(xev.RepoCommit)
 	case xev.RepoSync != nil && rsc.RepoSync != nil:
 		return rsc.RepoSync(xev.RepoSync)
-	case xev.RepoHandle != nil && rsc.RepoHandle != nil:
-		return rsc.RepoHandle(xev.RepoHandle)
 	case xev.RepoInfo != nil && rsc.RepoInfo != nil:
 		return rsc.RepoInfo(xev.RepoInfo)
-	case xev.RepoMigrate != nil && rsc.RepoMigrate != nil:
-		return rsc.RepoMigrate(xev.RepoMigrate)
 	case xev.RepoIdentity != nil && rsc.RepoIdentity != nil:
 		return rsc.RepoIdentity(xev.RepoIdentity)
 	case xev.RepoAccount != nil && rsc.RepoAccount != nil:
 		return rsc.RepoAccount(xev.RepoAccount)
-	case xev.RepoTombstone != nil && rsc.RepoTombstone != nil:
-		return rsc.RepoTombstone(xev.RepoTombstone)
 	case xev.LabelLabels != nil && rsc.LabelLabels != nil:
 		return rsc.LabelLabels(xev.LabelLabels)
 	case xev.LabelInfo != nil && rsc.LabelInfo != nil:
···
 				}); err != nil {
 					return err
 				}
-			case "#handle":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Handle
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq <= lastSeq {
-					logger.Error("got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-					continue
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoHandle: &evt,
-				}); err != nil {
-					return err
-				}
 			case "#identity":
 				var evt comatproto.SyncSubscribeRepos_Identity
 				if err := evt.UnmarshalCBOR(r); err != nil {
···
 
 				if err := sched.AddWork(ctx, "", &XRPCStreamEvent{
 					RepoInfo: &evt,
-				}); err != nil {
-					return err
-				}
-			case "#migrate":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Migrate
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq <= lastSeq {
-					logger.Error("got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-					continue
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoMigrate: &evt,
-				}); err != nil {
-					return err
-				}
-			case "#tombstone":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Tombstone
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq <= lastSeq {
-					logger.Error("got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-					continue
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoTombstone: &evt,
 				}); err != nil {
 					return err
 				}

cmd/relay/stream/events.go

···
 }
 
 type XRPCStreamEvent struct {
-	Error         *ErrorFrame
-	RepoCommit    *comatproto.SyncSubscribeRepos_Commit
-	RepoSync      *comatproto.SyncSubscribeRepos_Sync
-	RepoHandle    *comatproto.SyncSubscribeRepos_Handle // DEPRECATED
-	RepoIdentity  *comatproto.SyncSubscribeRepos_Identity
-	RepoInfo      *comatproto.SyncSubscribeRepos_Info
-	RepoMigrate   *comatproto.SyncSubscribeRepos_Migrate   // DEPRECATED
-	RepoTombstone *comatproto.SyncSubscribeRepos_Tombstone // DEPRECATED
-	RepoAccount   *comatproto.SyncSubscribeRepos_Account
-	LabelLabels   *comatproto.LabelSubscribeLabels_Labels
-	LabelInfo     *comatproto.LabelSubscribeLabels_Info
+	Error        *ErrorFrame
+	RepoCommit   *comatproto.SyncSubscribeRepos_Commit
+	RepoSync     *comatproto.SyncSubscribeRepos_Sync
+	RepoIdentity *comatproto.SyncSubscribeRepos_Identity
+	RepoInfo     *comatproto.SyncSubscribeRepos_Info
+	RepoAccount  *comatproto.SyncSubscribeRepos_Account
+	LabelLabels  *comatproto.LabelSubscribeLabels_Labels
+	LabelInfo    *comatproto.LabelSubscribeLabels_Info
 
 	// some private fields for internal routing perf
 	PrivUid         uint64 `json:"-" cborgen:"-"`
···
 	case evt.RepoSync != nil:
 		header.MsgType = "#sync"
 		obj = evt.RepoSync
-	case evt.RepoHandle != nil:
-		header.MsgType = "#handle"
-		obj = evt.RepoHandle
 	case evt.RepoIdentity != nil:
 		header.MsgType = "#identity"
 		obj = evt.RepoIdentity
···
 	case evt.RepoInfo != nil:
 		header.MsgType = "#info"
 		obj = evt.RepoInfo
-	case evt.RepoMigrate != nil:
-		header.MsgType = "#migrate"
-		obj = evt.RepoMigrate
-	case evt.RepoTombstone != nil:
-		header.MsgType = "#tombstone"
-		obj = evt.RepoTombstone
 	default:
 		return fmt.Errorf("unrecognized event kind")
 	}
···
 				return fmt.Errorf("reading repoSync event: %w", err)
 			}
 			xevt.RepoSync = &evt
-		case "#handle":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Handle
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoHandle = &evt
 		case "#identity":
 			var evt comatproto.SyncSubscribeRepos_Identity
 			if err := evt.UnmarshalCBOR(r); err != nil {
···
 				return err
 			}
 			xevt.RepoInfo = &evt
-		case "#migrate":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Migrate
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoMigrate = &evt
-		case "#tombstone":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Tombstone
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoTombstone = &evt
 		case "#labels":
 			var evt comatproto.LabelSubscribeLabels_Labels
 			if err := evt.UnmarshalCBOR(r); err != nil {
···
 		return evt.RepoCommit.Seq
 	case evt.RepoSync != nil:
 		return evt.RepoSync.Seq
-	case evt.RepoHandle != nil:
-		return evt.RepoHandle.Seq
-	case evt.RepoMigrate != nil:
-		return evt.RepoMigrate.Seq
-	case evt.RepoTombstone != nil:
-		return evt.RepoTombstone.Seq
 	case evt.RepoIdentity != nil:
 		return evt.RepoIdentity.Seq
 	case evt.RepoAccount != nil:
···
 		return evt.RepoCommit.Seq, true
 	case evt.RepoSync != nil:
 		return evt.RepoSync.Seq, true
-	case evt.RepoHandle != nil:
-		return evt.RepoHandle.Seq, true
-	case evt.RepoMigrate != nil:
-		return evt.RepoMigrate.Seq, true
-	case evt.RepoTombstone != nil:
-		return evt.RepoTombstone.Seq, true
 	case evt.RepoIdentity != nil:
 		return evt.RepoIdentity.Seq, true
 	case evt.RepoAccount != nil:

cmd/relay/stream/persist/diskpersist/diskpersist.go

···
 		pjob.Evt.RepoCommit.Seq = seq
 	case pjob.Evt.RepoSync != nil:
 		pjob.Evt.RepoSync.Seq = seq
-	case pjob.Evt.RepoHandle != nil:
-		pjob.Evt.RepoHandle.Seq = seq
 	case pjob.Evt.RepoIdentity != nil:
 		pjob.Evt.RepoIdentity.Seq = seq
 	case pjob.Evt.RepoAccount != nil:
 		pjob.Evt.RepoAccount.Seq = seq
-	case pjob.Evt.RepoTombstone != nil:
-		pjob.Evt.RepoTombstone.Seq = seq
 	default:
 		// only those three get peristed right now
 		// we should not actually ever get here...
···
 		if err := xevt.RepoSync.MarshalCBOR(cw); err != nil {
 			return fmt.Errorf("failed to marshal: %w", err)
 		}
-	case xevt.RepoHandle != nil:
-		evtKind = evtKindHandle
-		did = xevt.RepoHandle.Did
-		if err := xevt.RepoHandle.MarshalCBOR(cw); err != nil {
-			return fmt.Errorf("failed to marshal: %w", err)
-		}
 	case xevt.RepoIdentity != nil:
 		evtKind = evtKindIdentity
 		did = xevt.RepoIdentity.Did
···
 		evtKind = evtKindAccount
 		did = xevt.RepoAccount.Did
 		if err := xevt.RepoAccount.MarshalCBOR(cw); err != nil {
-			return fmt.Errorf("failed to marshal: %w", err)
-		}
-	case xevt.RepoTombstone != nil:
-		evtKind = evtKindTombstone
-		did = xevt.RepoTombstone.Did
-		if err := xevt.RepoTombstone.MarshalCBOR(cw); err != nil {
 			return fmt.Errorf("failed to marshal: %w", err)
 		}
 	default:
···
 			if err := cb(&stream.XRPCStreamEvent{RepoSync: &evt}); err != nil {
 				return nil, err
 			}
-		case evtKindHandle:
-			var evt atproto.SyncSubscribeRepos_Handle
-			if err := evt.UnmarshalCBOR(io.LimitReader(bufr, h.Len64())); err != nil {
-				return nil, err
-			}
-			evt.Seq = h.Seq
-			if err := cb(&stream.XRPCStreamEvent{RepoHandle: &evt}); err != nil {
-				return nil, err
-			}
 		case evtKindIdentity:
 			var evt atproto.SyncSubscribeRepos_Identity
 			if err := evt.UnmarshalCBOR(io.LimitReader(bufr, h.Len64())); err != nil {
···
 			}
 			evt.Seq = h.Seq
 			if err := cb(&stream.XRPCStreamEvent{RepoAccount: &evt}); err != nil {
-				return nil, err
-			}
-		case evtKindTombstone:
-			var evt atproto.SyncSubscribeRepos_Tombstone
-			if err := evt.UnmarshalCBOR(io.LimitReader(bufr, h.Len64())); err != nil {
-				return nil, err
-			}
-			evt.Seq = h.Seq
-			if err := cb(&stream.XRPCStreamEvent{RepoTombstone: &evt}); err != nil {
 				return nil, err
 			}
 		default:

cmd/relay/testing/consumer.go

···
 			c.LastSeq = evt.Seq
 			return nil
 		},
-		// NOTE: this is included to test that the events are *not* passed through; can be removed in the near future
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			c.eventsLk.Lock()
-			defer c.eventsLk.Unlock()
-			c.Events = append(c.Events, &stream.XRPCStreamEvent{RepoHandle: evt})
-			c.LastSeq = evt.Seq
-			return nil
-		},
 	}
 	return rsc
 }

cmd/sonar/sonar.go

···
 	case xe.RepoCommit != nil:
 		eventsProcessedCounter.WithLabelValues("repo_commit", s.SocketURL).Inc()
 		return s.HandleRepoCommit(ctx, xe.RepoCommit)
-	case xe.RepoHandle != nil:
-		eventsProcessedCounter.WithLabelValues("repo_handle", s.SocketURL).Inc()
-		now := time.Now()
-		s.ProgMux.Lock()
-		s.Progress.LastSeq = xe.RepoHandle.Seq
-		s.Progress.LastSeqProcessedAt = now
-		s.ProgMux.Unlock()
-		// Parse time from the event time string
-		t, err := time.Parse(time.RFC3339, xe.RepoHandle.Time)
-		if err != nil {
-			s.Logger.Error("error parsing time", "err", err)
-			return nil
-		}
-		lastEvtCreatedAtGauge.WithLabelValues(s.SocketURL).Set(float64(t.UnixNano()))
-		lastEvtProcessedAtGauge.WithLabelValues(s.SocketURL).Set(float64(now.UnixNano()))
-		lastEvtCreatedEvtProcessedGapGauge.WithLabelValues(s.SocketURL).Set(float64(now.Sub(t).Seconds()))
-		lastSeqGauge.WithLabelValues(s.SocketURL).Set(float64(xe.RepoHandle.Seq))
 	case xe.RepoIdentity != nil:
 		eventsProcessedCounter.WithLabelValues("identity", s.SocketURL).Inc()
 		now := time.Now()
···
 		s.ProgMux.Unlock()
 	case xe.RepoInfo != nil:
 		eventsProcessedCounter.WithLabelValues("repo_info", s.SocketURL).Inc()
-	case xe.RepoMigrate != nil:
-		eventsProcessedCounter.WithLabelValues("repo_migrate", s.SocketURL).Inc()
-		now := time.Now()
-		s.ProgMux.Lock()
-		s.Progress.LastSeq = xe.RepoMigrate.Seq
-		s.Progress.LastSeqProcessedAt = time.Now()
-		s.ProgMux.Unlock()
-		// Parse time from the event time string
-		t, err := time.Parse(time.RFC3339, xe.RepoMigrate.Time)
-		if err != nil {
-			s.Logger.Error("error parsing time", "err", err)
-			return nil
-		}
-		lastEvtCreatedAtGauge.WithLabelValues(s.SocketURL).Set(float64(t.UnixNano()))
-		lastEvtProcessedAtGauge.WithLabelValues(s.SocketURL).Set(float64(now.UnixNano()))
-		lastEvtCreatedEvtProcessedGapGauge.WithLabelValues(s.SocketURL).Set(float64(now.Sub(t).Seconds()))
-		lastSeqGauge.WithLabelValues(s.SocketURL).Set(float64(xe.RepoHandle.Seq))
-	case xe.RepoTombstone != nil:
-		eventsProcessedCounter.WithLabelValues("repo_tombstone", s.SocketURL).Inc()
 	case xe.LabelInfo != nil:
 		eventsProcessedCounter.WithLabelValues("label_info", s.SocketURL).Inc()
 	case xe.LabelLabels != nil:

cmd/supercollider/main.go

···
 				case evt.RepoCommit != nil:
 					header.MsgType = "#commit"
 					obj = evt.RepoCommit
-				case evt.RepoHandle != nil:
-					header.MsgType = "#handle"
-					obj = evt.RepoHandle
 				case evt.RepoInfo != nil:
 					header.MsgType = "#info"
 					obj = evt.RepoInfo
-				case evt.RepoMigrate != nil:
-					header.MsgType = "#migrate"
-					obj = evt.RepoMigrate
-				case evt.RepoTombstone != nil:
-					header.MsgType = "#tombstone"
-					obj = evt.RepoTombstone
 				default:
 					logger.Error("unrecognized event kind")
 					continue

events/consumer.go

···
 )
 
 type RepoStreamCallbacks struct {
-	RepoCommit    func(evt *comatproto.SyncSubscribeRepos_Commit) error
-	RepoSync      func(evt *comatproto.SyncSubscribeRepos_Sync) error
-	RepoHandle    func(evt *comatproto.SyncSubscribeRepos_Handle) error
-	RepoIdentity  func(evt *comatproto.SyncSubscribeRepos_Identity) error
-	RepoAccount   func(evt *comatproto.SyncSubscribeRepos_Account) error
-	RepoInfo      func(evt *comatproto.SyncSubscribeRepos_Info) error
-	RepoMigrate   func(evt *comatproto.SyncSubscribeRepos_Migrate) error
-	RepoTombstone func(evt *comatproto.SyncSubscribeRepos_Tombstone) error
-	LabelLabels   func(evt *comatproto.LabelSubscribeLabels_Labels) error
-	LabelInfo     func(evt *comatproto.LabelSubscribeLabels_Info) error
-	Error         func(evt *ErrorFrame) error
+	RepoCommit   func(evt *comatproto.SyncSubscribeRepos_Commit) error
+	RepoSync     func(evt *comatproto.SyncSubscribeRepos_Sync) error
+	RepoIdentity func(evt *comatproto.SyncSubscribeRepos_Identity) error
+	RepoAccount  func(evt *comatproto.SyncSubscribeRepos_Account) error
+	RepoInfo     func(evt *comatproto.SyncSubscribeRepos_Info) error
+	LabelLabels  func(evt *comatproto.LabelSubscribeLabels_Labels) error
+	LabelInfo    func(evt *comatproto.LabelSubscribeLabels_Info) error
+	Error        func(evt *ErrorFrame) error
 }
 
 func (rsc *RepoStreamCallbacks) EventHandler(ctx context.Context, xev *XRPCStreamEvent) error {
···
 		return rsc.RepoCommit(xev.RepoCommit)
 	case xev.RepoSync != nil && rsc.RepoSync != nil:
 		return rsc.RepoSync(xev.RepoSync)
-	case xev.RepoHandle != nil && rsc.RepoHandle != nil:
-		return rsc.RepoHandle(xev.RepoHandle)
 	case xev.RepoInfo != nil && rsc.RepoInfo != nil:
 		return rsc.RepoInfo(xev.RepoInfo)
-	case xev.RepoMigrate != nil && rsc.RepoMigrate != nil:
-		return rsc.RepoMigrate(xev.RepoMigrate)
 	case xev.RepoIdentity != nil && rsc.RepoIdentity != nil:
 		return rsc.RepoIdentity(xev.RepoIdentity)
 	case xev.RepoAccount != nil && rsc.RepoAccount != nil:
 		return rsc.RepoAccount(xev.RepoAccount)
-	case xev.RepoTombstone != nil && rsc.RepoTombstone != nil:
-		return rsc.RepoTombstone(xev.RepoTombstone)
 	case xev.LabelLabels != nil && rsc.LabelLabels != nil:
 		return rsc.LabelLabels(xev.LabelLabels)
 	case xev.LabelInfo != nil && rsc.LabelInfo != nil:
···
 				}); err != nil {
 					return err
 				}
-			case "#handle":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Handle
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq < lastSeq {
-					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoHandle: &evt,
-				}); err != nil {
-					return err
-				}
 			case "#identity":
 				var evt comatproto.SyncSubscribeRepos_Identity
 				if err := evt.UnmarshalCBOR(r); err != nil {
···
 
 				if err := sched.AddWork(ctx, "", &XRPCStreamEvent{
 					RepoInfo: &evt,
-				}); err != nil {
-					return err
-				}
-			case "#migrate":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Migrate
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq < lastSeq {
-					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoMigrate: &evt,
-				}); err != nil {
-					return err
-				}
-			case "#tombstone":
-				// TODO: DEPRECATED message; warning/counter; drop message
-				var evt comatproto.SyncSubscribeRepos_Tombstone
-				if err := evt.UnmarshalCBOR(r); err != nil {
-					return err
-				}
-
-				if evt.Seq < lastSeq {
-					log.Error("Got events out of order from stream", "seq", evt.Seq, "prev", lastSeq)
-				}
-				lastSeq = evt.Seq
-
-				if err := sched.AddWork(ctx, evt.Did, &XRPCStreamEvent{
-					RepoTombstone: &evt,
 				}); err != nil {
 					return err
 				}

events/dbpersist/dbpersist.go

···
 		switch {
 		case e.RepoCommit != nil:
 			e.RepoCommit.Seq = int64(item.Seq)
-		case e.RepoHandle != nil:
-			e.RepoHandle.Seq = int64(item.Seq)
+		case e.RepoSync != nil:
+			e.RepoSync.Seq = int64(item.Seq)
 		case e.RepoIdentity != nil:
 			e.RepoIdentity.Seq = int64(item.Seq)
 		case e.RepoAccount != nil:
 			e.RepoAccount.Seq = int64(item.Seq)
-		case e.RepoTombstone != nil:
-			e.RepoTombstone.Seq = int64(item.Seq)
 		default:
 			return fmt.Errorf("unknown event type")
 		}
···
 		if err != nil {
 			return err
 		}
-	case e.RepoHandle != nil:
-		rer, err = p.RecordFromHandleChange(ctx, e.RepoHandle)
+	case e.RepoSync != nil:
+		rer, err = p.RecordFromRepoSync(ctx, e.RepoSync)
 		if err != nil {
 			return err
 		}
···
 		if err != nil {
 			return err
 		}
-	case e.RepoTombstone != nil:
-		rer, err = p.RecordFromTombstone(ctx, e.RepoTombstone)
-		if err != nil {
-			return err
-		}
 	default:
 		return nil
 	}
···
 	}
 
 	return nil
-}
-
-func (p *DbPersistence) RecordFromHandleChange(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Handle) (*RepoEventRecord, error) {
-	t, err := time.Parse(util.ISO8601, evt.Time)
-	if err != nil {
-		return nil, err
-	}
-
-	uid, err := p.uidForDid(ctx, evt.Did)
-	if err != nil {
-		return nil, err
-	}
-
-	return &RepoEventRecord{
-		Repo:      uid,
-		Type:      "repo_handle",
-		Time:      t,
-		NewHandle: &evt.Handle,
-	}, nil
 }
 
 func (p *DbPersistence) RecordFromRepoIdentity(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Identity) (*RepoEventRecord, error) {
···
 	}, nil
 }
 
-func (p *DbPersistence) RecordFromTombstone(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Tombstone) (*RepoEventRecord, error) {
-	t, err := time.Parse(util.ISO8601, evt.Time)
-	if err != nil {
-		return nil, err
-	}
-
-	uid, err := p.uidForDid(ctx, evt.Did)
-	if err != nil {
-		return nil, err
-	}
-
-	return &RepoEventRecord{
-		Repo: uid,
-		Type: "repo_tombstone",
-		Time: t,
-	}, nil
-}
-
 func (p *DbPersistence) RecordFromRepoCommit(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Commit) (*RepoEventRecord, error) {
 	// TODO: hack hack hack
 	if len(evt.Ops) > 8192 {
···
 	return &rer, nil
 }
 
+func (p *DbPersistence) RecordFromRepoSync(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Sync) (*RepoEventRecord, error) {
+
+	uid, err := p.uidForDid(ctx, evt.Did)
+	if err != nil {
+		return nil, err
+	}
+
+	t, err := time.Parse(util.ISO8601, evt.Time)
+	if err != nil {
+		return nil, err
+	}
+
+	rer := RepoEventRecord{
+		Repo: uid,
+		Type: "repo_sync",
+		Time: t,
+		Rev:  evt.Rev,
+	}
+
+	return &rer, nil
+}
+
 func (p *DbPersistence) Playback(ctx context.Context, since int64, cb func(*events.XRPCStreamEvent) error) error {
 	pageSize := 1000
 
···
 			switch {
 			case record.Commit != nil:
 				streamEvent, err = p.hydrateCommit(ctx, record)
-			case record.NewHandle != nil:
-				streamEvent, err = p.hydrateHandleChange(ctx, record)
+			case record.Type == "repo_sync":
+				streamEvent, err = p.hydrateSyncEvent(ctx, record)
 			case record.Type == "repo_identity":
 				streamEvent, err = p.hydrateIdentityEvent(ctx, record)
 			case record.Type == "repo_account":
 				streamEvent, err = p.hydrateAccountEvent(ctx, record)
-			case record.Type == "repo_tombstone":
-				streamEvent, err = p.hydrateTombstone(ctx, record)
 			default:
 				err = fmt.Errorf("unknown event type: %s", record.Type)
 			}
···
 	return u.Did, nil
 }
 
-func (p *DbPersistence) hydrateHandleChange(ctx context.Context, rer *RepoEventRecord) (*events.XRPCStreamEvent, error) {
-	if rer.NewHandle == nil {
-		return nil, fmt.Errorf("NewHandle is nil")
-	}
-
-	did, err := p.didForUid(ctx, rer.Repo)
-	if err != nil {
-		return nil, err
-	}
-
-	return &events.XRPCStreamEvent{
-		RepoHandle: &comatproto.SyncSubscribeRepos_Handle{
-			Did:    did,
-			Handle: *rer.NewHandle,
-			Time:   rer.Time.Format(util.ISO8601),
-		},
-	}, nil
-}
-
 func (p *DbPersistence) hydrateIdentityEvent(ctx context.Context, rer *RepoEventRecord) (*events.XRPCStreamEvent, error) {
 	did, err := p.didForUid(ctx, rer.Repo)
 	if err != nil {
···
 	}, nil
 }
 
-func (p *DbPersistence) hydrateTombstone(ctx context.Context, rer *RepoEventRecord) (*events.XRPCStreamEvent, error) {
-	did, err := p.didForUid(ctx, rer.Repo)
-	if err != nil {
-		return nil, err
-	}
-
-	return &events.XRPCStreamEvent{
-		RepoTombstone: &comatproto.SyncSubscribeRepos_Tombstone{
-			Did:  did,
-			Time: rer.Time.Format(util.ISO8601),
-		},
-	}, nil
-}
-
 func (p *DbPersistence) hydrateCommit(ctx context.Context, rer *RepoEventRecord) (*events.XRPCStreamEvent, error) {
 	if rer.Commit == nil {
 		return nil, fmt.Errorf("commit is nil")
···
 	}
 
 	return &events.XRPCStreamEvent{RepoCommit: out}, nil
+}
+
+func (p *DbPersistence) hydrateSyncEvent(ctx context.Context, rer *RepoEventRecord) (*events.XRPCStreamEvent, error) {
+
+	did, err := p.didForUid(ctx, rer.Repo)
+	if err != nil {
+		return nil, err
+	}
+
+	evt := &comatproto.SyncSubscribeRepos_Sync{
+		Seq:  int64(rer.Seq),
+		Did:  did,
+		Time: rer.Time.Format(util.ISO8601),
+		Rev:  rer.Rev,
+	}
+
+	cs, err := p.readCarSlice(ctx, rer)
+	if err != nil {
+		return nil, fmt.Errorf("read car slice: %w", err)
+	}
+	evt.Blocks = cs
+
+	return &events.XRPCStreamEvent{RepoSync: evt}, nil
 }
 
 func (p *DbPersistence) readCarSlice(ctx context.Context, rer *RepoEventRecord) ([]byte, error) {

events/diskpersist/diskpersist.go

···
 	evtKindTombstone = 3
 	evtKindIdentity  = 4
 	evtKindAccount   = 5
+	evtKindSync      = 6
 )
 
 var emptyHeader = make([]byte, headerSize)
···
 	switch {
 	case e.RepoCommit != nil:
 		e.RepoCommit.Seq = seq
-	case e.RepoHandle != nil:
-		e.RepoHandle.Seq = seq
+	case e.RepoSync != nil:
+		e.RepoSync.Seq = seq
 	case e.RepoIdentity != nil:
 		e.RepoIdentity.Seq = seq
 	case e.RepoAccount != nil:
 		e.RepoAccount.Seq = seq
-	case e.RepoTombstone != nil:
-		e.RepoTombstone.Seq = seq
 	default:
 		// only those three get peristed right now
 		// we should not actually ever get here...
···
 		if err := e.RepoCommit.MarshalCBOR(cw); err != nil {
 			return fmt.Errorf("failed to marshal: %w", err)
 		}
-	case e.RepoHandle != nil:
-		evtKind = evtKindHandle
-		did = e.RepoHandle.Did
-		if err := e.RepoHandle.MarshalCBOR(cw); err != nil {
+	case e.RepoSync != nil:
+		evtKind = evtKindSync
+		did = e.RepoSync.Did
+		if err := e.RepoSync.MarshalCBOR(cw); err != nil {
 			return fmt.Errorf("failed to marshal: %w", err)
 		}
 	case e.RepoIdentity != nil:
···
 		if err := e.RepoAccount.MarshalCBOR(cw); err != nil {
 			return fmt.Errorf("failed to marshal: %w", err)
 		}
-	case e.RepoTombstone != nil:
-		evtKind = evtKindTombstone
-		did = e.RepoTombstone.Did
-		if err := e.RepoTombstone.MarshalCBOR(cw); err != nil {
-			return fmt.Errorf("failed to marshal: %w", err)
-		}
 	default:
 		return nil
 		// only those two get peristed right now
···
 			if err := cb(&events.XRPCStreamEvent{RepoCommit: &evt}); err != nil {
 				return nil, err
 			}
-		case evtKindHandle:
-			var evt atproto.SyncSubscribeRepos_Handle
+		case evtKindSync:
+			var evt atproto.SyncSubscribeRepos_Sync
 			if err := evt.UnmarshalCBOR(io.LimitReader(bufr, h.Len64())); err != nil {
 				return nil, err
 			}
 			evt.Seq = h.Seq
-			if err := cb(&events.XRPCStreamEvent{RepoHandle: &evt}); err != nil {
+			if err := cb(&events.XRPCStreamEvent{RepoSync: &evt}); err != nil {
 				return nil, err
 			}
 		case evtKindIdentity:
···
 			}
 			evt.Seq = h.Seq
 			if err := cb(&events.XRPCStreamEvent{RepoAccount: &evt}); err != nil {
-				return nil, err
-			}
-		case evtKindTombstone:
-			var evt atproto.SyncSubscribeRepos_Tombstone
-			if err := evt.UnmarshalCBOR(io.LimitReader(bufr, h.Len64())); err != nil {
-				return nil, err
-			}
-			evt.Seq = h.Seq
-			if err := cb(&events.XRPCStreamEvent{RepoTombstone: &evt}); err != nil {
 				return nil, err
 			}
 		default:

events/events.go

···
 }
 
 type XRPCStreamEvent struct {
-	Error         *ErrorFrame
-	RepoCommit    *comatproto.SyncSubscribeRepos_Commit
-	RepoSync      *comatproto.SyncSubscribeRepos_Sync
-	RepoHandle    *comatproto.SyncSubscribeRepos_Handle // DEPRECATED
-	RepoIdentity  *comatproto.SyncSubscribeRepos_Identity
-	RepoInfo      *comatproto.SyncSubscribeRepos_Info
-	RepoMigrate   *comatproto.SyncSubscribeRepos_Migrate   // DEPRECATED
-	RepoTombstone *comatproto.SyncSubscribeRepos_Tombstone // DEPRECATED
-	RepoAccount   *comatproto.SyncSubscribeRepos_Account
-	LabelLabels   *comatproto.LabelSubscribeLabels_Labels
-	LabelInfo     *comatproto.LabelSubscribeLabels_Info
+	Error        *ErrorFrame
+	RepoCommit   *comatproto.SyncSubscribeRepos_Commit
+	RepoSync     *comatproto.SyncSubscribeRepos_Sync
+	RepoIdentity *comatproto.SyncSubscribeRepos_Identity
+	RepoInfo     *comatproto.SyncSubscribeRepos_Info
+	RepoAccount  *comatproto.SyncSubscribeRepos_Account
+	LabelLabels  *comatproto.LabelSubscribeLabels_Labels
+	LabelInfo    *comatproto.LabelSubscribeLabels_Info
 
 	// some private fields for internal routing perf
 	PrivUid         models.Uid `json:"-" cborgen:"-"`
···
 	case evt.RepoSync != nil:
 		header.MsgType = "#sync"
 		obj = evt.RepoSync
-	case evt.RepoHandle != nil:
-		header.MsgType = "#handle"
-		obj = evt.RepoHandle
 	case evt.RepoIdentity != nil:
 		header.MsgType = "#identity"
 		obj = evt.RepoIdentity
···
 	case evt.RepoInfo != nil:
 		header.MsgType = "#info"
 		obj = evt.RepoInfo
-	case evt.RepoMigrate != nil:
-		header.MsgType = "#migrate"
-		obj = evt.RepoMigrate
-	case evt.RepoTombstone != nil:
-		header.MsgType = "#tombstone"
-		obj = evt.RepoTombstone
 	default:
 		return fmt.Errorf("unrecognized event kind")
 	}
···
 				return fmt.Errorf("reading repoSync event: %w", err)
 			}
 			xevt.RepoSync = &evt
-		case "#handle":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Handle
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoHandle = &evt
 		case "#identity":
 			var evt comatproto.SyncSubscribeRepos_Identity
 			if err := evt.UnmarshalCBOR(r); err != nil {
···
 				return err
 			}
 			xevt.RepoInfo = &evt
-		case "#migrate":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Migrate
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoMigrate = &evt
-		case "#tombstone":
-			// TODO: DEPRECATED message; warning/counter; drop message
-			var evt comatproto.SyncSubscribeRepos_Tombstone
-			if err := evt.UnmarshalCBOR(r); err != nil {
-				return err
-			}
-			xevt.RepoTombstone = &evt
 		case "#labels":
 			var evt comatproto.LabelSubscribeLabels_Labels
 			if err := evt.UnmarshalCBOR(r); err != nil {
···
 		return evt.RepoCommit.Seq
 	case evt.RepoSync != nil:
 		return evt.RepoSync.Seq
-	case evt.RepoHandle != nil:
-		return evt.RepoHandle.Seq
-	case evt.RepoMigrate != nil:
-		return evt.RepoMigrate.Seq
-	case evt.RepoTombstone != nil:
-		return evt.RepoTombstone.Seq
 	case evt.RepoIdentity != nil:
 		return evt.RepoIdentity.Seq
 	case evt.RepoAccount != nil:
···
 		return evt.RepoCommit.Seq, true
 	case evt.RepoSync != nil:
 		return evt.RepoSync.Seq, true
-	case evt.RepoHandle != nil:
-		return evt.RepoHandle.Seq, true
-	case evt.RepoMigrate != nil:
-		return evt.RepoMigrate.Seq, true
-	case evt.RepoTombstone != nil:
-		return evt.RepoTombstone.Seq, true
 	case evt.RepoIdentity != nil:
 		return evt.RepoIdentity.Seq, true
 	case evt.RepoAccount != nil:

events/persist.go

···
 	switch {
 	case e.RepoCommit != nil:
 		e.RepoCommit.Seq = mp.seq
-	case e.RepoHandle != nil:
-		e.RepoHandle.Seq = mp.seq
 	case e.RepoIdentity != nil:
 		e.RepoIdentity.Seq = mp.seq
 	case e.RepoAccount != nil:
 		e.RepoAccount.Seq = mp.seq
-	case e.RepoMigrate != nil:
-		e.RepoMigrate.Seq = mp.seq
-	case e.RepoTombstone != nil:
-		e.RepoTombstone.Seq = mp.seq
 	case e.LabelLabels != nil:
 		e.LabelLabels.Seq = mp.seq
 	default:

events/yolopersist/yolopersist.go

···
 	switch {
 	case e.RepoCommit != nil:
 		e.RepoCommit.Seq = yp.seq
-	case e.RepoHandle != nil:
-		e.RepoHandle.Seq = yp.seq
+	case e.RepoSync != nil:
+		e.RepoSync.Seq = yp.seq
 	case e.RepoIdentity != nil:
 		e.RepoIdentity.Seq = yp.seq
 	case e.RepoAccount != nil:
 		e.RepoAccount.Seq = yp.seq
-	case e.RepoMigrate != nil:
-		e.RepoMigrate.Seq = yp.seq
-	case e.RepoTombstone != nil:
-		e.RepoTombstone.Seq = yp.seq
 	case e.LabelLabels != nil:
 		e.LabelLabels.Seq = yp.seq
 	default:

gen/main.go

···
 		atproto.RepoStrongRef{},
 		atproto.SyncSubscribeRepos_Commit{},
 		atproto.SyncSubscribeRepos_Sync{},
-		atproto.SyncSubscribeRepos_Handle{},
 		atproto.SyncSubscribeRepos_Identity{},
 		atproto.SyncSubscribeRepos_Account{},
 		atproto.SyncSubscribeRepos_Info{},
-		atproto.SyncSubscribeRepos_Migrate{},
 		atproto.SyncSubscribeRepos_RepoOp{},
-		atproto.SyncSubscribeRepos_Tombstone{},
 		atproto.LabelDefs_SelfLabels{},
 		atproto.LabelDefs_SelfLabel{},
 		atproto.LabelDefs_Label{},

lex/gen.go

···
 	pf("\t\"fmt\"\n")
 	pf("\t\"encoding/json\"\n")
 	pf("\tcbg \"github.com/whyrusleeping/cbor-gen\"\n")
-	pf("\t\"github.com/bluesky-social/indigo/xrpc\"\n")
 	pf("\t\"github.com/bluesky-social/indigo/lex/util\"\n")
 	for _, xpkg := range packages {
 		if xpkg.Prefix != pkg.Prefix {
···
 	return packages, nil
 }
 
-func Run(schemas []*Schema, packages []Package) error {
-	defmap := BuildExtDefMap(schemas, packages)
+func Run(schemas []*Schema, externalSchemas []*Schema, packages []Package) error {
+	defmap := BuildExtDefMap(append(schemas, externalSchemas...), packages)
 
 	for _, pkg := range packages {
 		prefix := pkg.Prefix

lex/type_schema.go

···
 	pf := printerf(w)
 	fname := typename
 
-	params := "ctx context.Context, c *xrpc.Client"
+	params := "ctx context.Context, c util.LexClient"
 	inpvar := "nil"
 	inpenc := ""
 
···
 	var reqtype string
 	switch s.Type {
 	case "procedure":
-		reqtype = "xrpc.Procedure"
+		reqtype = "util.Procedure"
 	case "query":
-		reqtype = "xrpc.Query"
+		reqtype = "util.Query"
 	default:
 		return fmt.Errorf("can only generate RPC for Query or Procedure (got %s)", s.Type)
 	}
 
-	pf("\tif err := c.Do(ctx, %s, %q, \"%s\", %s, %s, %s); err != nil {\n", reqtype, inpenc, s.id, queryparams, inpvar, outvar)
+	pf("\tif err := c.LexDo(ctx, %s, %q, \"%s\", %s, %s, %s); err != nil {\n", reqtype, inpenc, s.id, queryparams, inpvar, outvar)
 	pf("\t\treturn %s\n", errRet)
 	pf("\t}\n\n")
 	pf("\treturn %s\n", outRet)

lex/util/client.go

···
+package util
+
+import (
+	"context"
+	"net/http"
+)
+
+const (
+	Query     = http.MethodGet
+	Procedure = http.MethodPost
+)
+
+// API client interface used in lexgen.
+//
+// 'method' is the HTTP method type. 'inputEncoding' is the Content-Type for bodyData in Procedure calls. 'params' are query parameters. 'bodyData' should be either 'nil', an [io.Reader], or a type which can be marshalled to JSON. 'out' is optional; if not nil it should be a pointer to a type which can be un-Marshaled as JSON, for the response body.
+type LexClient interface {
+	LexDo(ctx context.Context, method string, inputEncoding string, endpoint string, params map[string]any, bodyData any, out any) error
+}

pds/server.go

···
 		case evt.RepoCommit != nil:
 			header.MsgType = "#commit"
 			obj = evt.RepoCommit
-		case evt.RepoHandle != nil:
-			header.MsgType = "#handle"
-			obj = evt.RepoHandle
 		case evt.RepoIdentity != nil:
 			header.MsgType = "#identity"
 			obj = evt.RepoIdentity
···
 		case evt.RepoInfo != nil:
 			header.MsgType = "#info"
 			obj = evt.RepoInfo
-		case evt.RepoMigrate != nil:
-			header.MsgType = "#migrate"
-			obj = evt.RepoMigrate
-		case evt.RepoTombstone != nil:
-			header.MsgType = "#tombstone"
-			obj = evt.RepoTombstone
 		default:
 			return fmt.Errorf("unrecognized event kind")
 		}
···
 		return fmt.Errorf("failed to update handle: %w", err)
 	}
 
-	if err := s.events.AddEvent(ctx, &events.XRPCStreamEvent{
-		RepoHandle: &comatproto.SyncSubscribeRepos_Handle{
-			Did:    u.Did,
-			Handle: handle,
-			Time:   time.Now().Format(util.ISO8601),
-		},
-	}); err != nil {
-		return fmt.Errorf("failed to push event: %s", err)
-	}
-
-	// Also push an Identity event
 	if err := s.events.AddEvent(ctx, &events.XRPCStreamEvent{
 		RepoIdentity: &comatproto.SyncSubscribeRepos_Identity{
 			Did:  u.Did,

search/firehose.go

···
 			return nil
 
 		},
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			ctx := context.Background()
-			ctx, span := tracer.Start(ctx, "RepoHandle")
-			defer span.End()
-
-			did, err := syntax.ParseDID(evt.Did)
-			if err != nil {
-				idx.logger.Error("bad DID in RepoHandle event", "did", evt.Did, "handle", evt.Handle, "seq", evt.Seq, "err", err)
-				return nil
-			}
-			if err := idx.updateUserHandle(ctx, did, evt.Handle); err != nil {
-				// TODO: handle this case (instead of return nil)
-				idx.logger.Error("failed to update user handle", "did", evt.Did, "handle", evt.Handle, "seq", evt.Seq, "err", err)
-			}
-			return nil
-		},
 	}
 
 	return events.HandleRepoStream(

testing/integ_test.go

···
 
 	initevt := evts.Next()
 	t.Log(initevt.RepoCommit)
-	hcevt := evts.Next()
-	t.Log(hcevt.RepoHandle)
 	idevt := evts.Next()
 	t.Log(idevt.RepoIdentity)
 }

testing/utils.go

···
 				es.Lk.Unlock()
 				return nil
 			},
-			RepoHandle: func(evt *atproto.SyncSubscribeRepos_Handle) error {
-				fmt.Println("received handle event: ", evt.Seq, evt.Did)
-				es.Lk.Lock()
-				es.Events = append(es.Events, &events.XRPCStreamEvent{RepoHandle: evt})
-				es.Lk.Unlock()
-				return nil
-			},
 			RepoIdentity: func(evt *atproto.SyncSubscribeRepos_Identity) error {
 				fmt.Println("received identity event: ", evt.Seq, evt.Did)
 				es.Lk.Lock()

xrpc/xrpc.go

···
 	return c.Client
 }
 
-type XRPCRequestType int
+var (
+	Query     = http.MethodGet
+	Procedure = http.MethodPost
+)
 
 type AuthInfo struct {
 	AccessJwt  string `json:"accessJwt"`
···
 	Reset     time.Time
 }
 
-const (
-	Query = XRPCRequestType(iota)
-	Procedure
-)
-
 // makeParams converts a map of string keys and any values into a URL-encoded string.
 // If a value is a slice of strings, it will be joined with commas.
 // Generally the values will be strings, numbers, booleans, or slices of strings
···
 	return params.Encode()
 }
 
-func (c *Client) Do(ctx context.Context, kind XRPCRequestType, inpenc string, method string, params map[string]interface{}, bodyobj interface{}, out interface{}) error {
+func (c *Client) Do(ctx context.Context, kind string, inpenc string, method string, params map[string]interface{}, bodyobj interface{}, out interface{}) error {
 	var body io.Reader
 	if bodyobj != nil {
 		if rr, ok := bodyobj.(io.Reader); ok {
···
 	case Procedure:
 		m = "POST"
 	default:
-		return fmt.Errorf("unsupported request kind: %d", kind)
+		return fmt.Errorf("unsupported request kind: %s", kind)
 	}
 
 	var paramStr string
···
 
 	return nil
 }
+
+func (c *Client) LexDo(ctx context.Context, method string, inputEncoding string, endpoint string, params map[string]any, bodyData any, out any) error {
+	return c.Do(ctx, method, inputEncoding, endpoint, params, bodyData, out)
+}