remove all the unused event fields

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/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 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"`
 	// revokeReason: Describes the reason for revocation, also indicating that the verification is no longer valid.
 	RevokeReason *string `json:"revokeReason,omitempty" cborgen:"revokeReason,omitempty"`
···
 	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"`
 	// uri: The AT-URI of the verification record.
 	Uri string `json:"uri" cborgen:"uri"`

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/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/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.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)
-		if err != nil {
-			return err
-		}
 	case e.RepoIdentity != nil:
 		rer, err = p.RecordFromRepoIdentity(ctx, e.RepoIdentity)
 		if err != nil {
···
 		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) {
 	t, err := time.Parse(util.ISO8601, evt.Time)
 	if err != nil {
···
 	}, 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 {
···
 			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_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 {
···
 			Time:   rer.Time.Format(util.ISO8601),
 			Active: rer.Active,
 			Status: rer.Status,
-		},
-	}, 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
 }

events/diskpersist/diskpersist.go

···
 	switch {
 	case e.RepoCommit != nil:
 		e.RepoCommit.Seq = seq
-	case e.RepoHandle != nil:
-		e.RepoHandle.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 {
-			return fmt.Errorf("failed to marshal: %w", err)
-		}
 	case e.RepoIdentity != nil:
 		evtKind = evtKindIdentity
 		did = e.RepoIdentity.Did
···
 		evtKind = evtKindAccount
 		did = e.RepoAccount.Did
 		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:
···
 			if err := cb(&events.XRPCStreamEvent{RepoCommit: &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(&events.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(&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.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{},

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()