:rightwards_twisted_arrows: Merge with upstream

api/atproto/admindefs.go

···
 
 // AdminDefs_AccountView is a "accountView" in the com.atproto.admin.defs schema.
 type AdminDefs_AccountView struct {
-	DeactivatedAt    *string                    `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
-	Did              string                     `json:"did" cborgen:"did"`
-	Email            *string                    `json:"email,omitempty" cborgen:"email,omitempty"`
-	EmailConfirmedAt *string                    `json:"emailConfirmedAt,omitempty" cborgen:"emailConfirmedAt,omitempty"`
-	Handle           string                     `json:"handle" cborgen:"handle"`
-	IndexedAt        string                     `json:"indexedAt" cborgen:"indexedAt"`
-	InviteNote       *string                    `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
-	InvitedBy        *ServerDefs_InviteCode     `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
-	Invites          []*ServerDefs_InviteCode   `json:"invites,omitempty" cborgen:"invites,omitempty"`
-	InvitesDisabled  *bool                      `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
-	RelatedRecords   []*util.LexiconTypeDecoder `json:"relatedRecords,omitempty" cborgen:"relatedRecords,omitempty"`
+	DeactivatedAt    *string                      `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
+	Did              string                       `json:"did" cborgen:"did"`
+	Email            *string                      `json:"email,omitempty" cborgen:"email,omitempty"`
+	EmailConfirmedAt *string                      `json:"emailConfirmedAt,omitempty" cborgen:"emailConfirmedAt,omitempty"`
+	Handle           string                       `json:"handle" cborgen:"handle"`
+	IndexedAt        string                       `json:"indexedAt" cborgen:"indexedAt"`
+	InviteNote       *string                      `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
+	InvitedBy        *ServerDefs_InviteCode       `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
+	Invites          []*ServerDefs_InviteCode     `json:"invites,omitempty" cborgen:"invites,omitempty"`
+	InvitesDisabled  *bool                        `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
+	RelatedRecords   []*util.LexiconTypeDecoder   `json:"relatedRecords,omitempty" cborgen:"relatedRecords,omitempty"`
+	ThreatSignatures []*AdminDefs_ThreatSignature `json:"threatSignatures,omitempty" cborgen:"threatSignatures,omitempty"`
 }
 
 // AdminDefs_RepoBlobRef is a "repoBlobRef" in the com.atproto.admin.defs schema.
···
 	Applied bool    `json:"applied" cborgen:"applied"`
 	Ref     *string `json:"ref,omitempty" cborgen:"ref,omitempty"`
 }
+
+// AdminDefs_ThreatSignature is a "threatSignature" in the com.atproto.admin.defs schema.
+type AdminDefs_ThreatSignature struct {
+	Property string `json:"property" cborgen:"property"`
+	Value    string `json:"value" cborgen:"value"`
+}

api/atproto/cbor_gen.go

···
 		return fmt.Errorf("RepoStrongRef: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (string) (string)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Commit: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Ops ([]*atproto.SyncSubscribeRepos_RepoOp) (slice)
 		case "ops":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Handle: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Identity: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Account: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Info: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Name (string) (string)
 		case "name":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Migrate: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_RepoOp: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (util.LexLink) (struct)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("SyncSubscribeRepos_Tombstone: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelDefs_SelfLabels: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelDefs_SelfLabel: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 3)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Val (string) (string)
 		case "val":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelDefs_Label: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 3)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (string) (string)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelSubscribeLabels_Labels: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Seq (int64) (int64)
 		case "seq":
 			{
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelSubscribeLabels_Info: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Name (string) (string)
 		case "name":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelDefs_LabelValueDefinition: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 14)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Blurs (string) (string)
 		case "blurs":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelDefs_LabelValueDefinitionStrings: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Lang (string) (string)
 		case "lang":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

api/bsky/cbor_gen.go

···
 		return fmt.Errorf("FeedPost: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Tags ([]string) (slice)
 		case "tags":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedRepost: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedPost_Entity: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Type (string) (string)
 		case "type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedPost_ReplyRef: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Root (atproto.RepoStrongRef) (struct)
 		case "root":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedPost_TextSlice: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.End (int64) (int64)
 		case "end":
 			{
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedImages: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedExternal: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedExternal_External: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Uri (string) (string)
 		case "uri":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedImages_Image: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Alt (string) (string)
 		case "alt":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphFollow: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("ActorProfile: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 20)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedRecord: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedLike: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("RichtextFacet: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Index (bsky.RichtextFacet_ByteSlice) (struct)
 		case "index":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("RichtextFacet_ByteSlice: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.ByteEnd (int64) (int64)
 		case "byteEnd":
 			{
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("RichtextFacet_Link: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Uri (string) (string)
 		case "uri":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("RichtextFacet_Mention: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("RichtextFacet_Tag: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Tag (string) (string)
 		case "tag":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedRecordWithMedia: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedDefs_NotFoundPost: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Uri (string) (string)
 		case "uri":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphBlock: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphList: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 17)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Name (string) (string)
 		case "name":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphListitem: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.List (string) (string)
 		case "list":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedGenerator: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 19)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphListblock: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedDefs_AspectRatio: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Width (int64) (int64)
 		case "width":
 			{
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedThreadgate: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 13)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Post (string) (string)
 		case "post":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedThreadgate_ListRule: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.List (string) (string)
 		case "list":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedThreadgate_MentionRule: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedThreadgate_FollowingRule: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphStarterpack_FeedItem: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 3)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Uri (string) (string)
 		case "uri":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("GraphStarterpack: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 17)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.List (string) (string)
 		case "list":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelerService: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LabelerDefs_LabelerPolicies: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 21)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LabelValues ([]*string) (slice)
 		case "labelValues":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedVideo: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Alt (string) (string)
 		case "alt":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("EmbedVideo_Caption: map struct too large (%d)", extra)
 	}
 
-	var name string
 	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
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.File (util.LexBlob) (struct)
 		case "file":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedPostgate: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 21)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Post (string) (string)
 		case "post":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("FeedPostgate_DisableRule: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

api/bsky/unspeccedgetConfig.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package bsky
+
+// schema: app.bsky.unspecced.getConfig
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// UnspeccedGetConfig_Output is the output of a app.bsky.unspecced.getConfig call.
+type UnspeccedGetConfig_Output struct {
+	CheckEmailConfirmed *bool `json:"checkEmailConfirmed,omitempty" cborgen:"checkEmailConfirmed,omitempty"`
+}
+
+// UnspeccedGetConfig calls the XRPC method "app.bsky.unspecced.getConfig".
+func UnspeccedGetConfig(ctx context.Context, c *xrpc.Client) (*UnspeccedGetConfig_Output, error) {
+	var out UnspeccedGetConfig_Output
+	if err := c.Do(ctx, xrpc.Query, "", "app.bsky.unspecced.getConfig", nil, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/cbor_gen.go

···
 		return fmt.Errorf("CreateOp: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 11)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Sig (string) (string)
 		case "sig":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

api/chat/cbor_gen.go

···
 		return fmt.Errorf("ActorDeclaration: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 13)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.LexiconTypeID (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

api/ozone/moderationdefs.go

···
 //
 // RECORDTYPE: ModerationDefs_RepoView
 type ModerationDefs_RepoView struct {
-	LexiconTypeID   string                                 `json:"$type,const=tools.ozone.moderation.defs#repoView" cborgen:"$type,const=tools.ozone.moderation.defs#repoView"`
-	DeactivatedAt   *string                                `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
-	Did             string                                 `json:"did" cborgen:"did"`
-	Email           *string                                `json:"email,omitempty" cborgen:"email,omitempty"`
-	Handle          string                                 `json:"handle" cborgen:"handle"`
-	IndexedAt       string                                 `json:"indexedAt" cborgen:"indexedAt"`
-	InviteNote      *string                                `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
-	InvitedBy       *comatprototypes.ServerDefs_InviteCode `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
-	InvitesDisabled *bool                                  `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
-	Moderation      *ModerationDefs_Moderation             `json:"moderation" cborgen:"moderation"`
-	RelatedRecords  []*util.LexiconTypeDecoder             `json:"relatedRecords" cborgen:"relatedRecords"`
+	LexiconTypeID    string                                       `json:"$type,const=tools.ozone.moderation.defs#repoView" cborgen:"$type,const=tools.ozone.moderation.defs#repoView"`
+	DeactivatedAt    *string                                      `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
+	Did              string                                       `json:"did" cborgen:"did"`
+	Email            *string                                      `json:"email,omitempty" cborgen:"email,omitempty"`
+	Handle           string                                       `json:"handle" cborgen:"handle"`
+	IndexedAt        string                                       `json:"indexedAt" cborgen:"indexedAt"`
+	InviteNote       *string                                      `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
+	InvitedBy        *comatprototypes.ServerDefs_InviteCode       `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
+	InvitesDisabled  *bool                                        `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
+	Moderation       *ModerationDefs_Moderation                   `json:"moderation" cborgen:"moderation"`
+	RelatedRecords   []*util.LexiconTypeDecoder                   `json:"relatedRecords" cborgen:"relatedRecords"`
+	ThreatSignatures []*comatprototypes.AdminDefs_ThreatSignature `json:"threatSignatures,omitempty" cborgen:"threatSignatures,omitempty"`
 }
 
 // ModerationDefs_RepoViewDetail is a "repoViewDetail" in the tools.ozone.moderation.defs schema.
 //
 // RECORDTYPE: ModerationDefs_RepoViewDetail
 type ModerationDefs_RepoViewDetail struct {
-	LexiconTypeID    string                                   `json:"$type,const=tools.ozone.moderation.defs#repoViewDetail" cborgen:"$type,const=tools.ozone.moderation.defs#repoViewDetail"`
-	DeactivatedAt    *string                                  `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
-	Did              string                                   `json:"did" cborgen:"did"`
-	Email            *string                                  `json:"email,omitempty" cborgen:"email,omitempty"`
-	EmailConfirmedAt *string                                  `json:"emailConfirmedAt,omitempty" cborgen:"emailConfirmedAt,omitempty"`
-	Handle           string                                   `json:"handle" cborgen:"handle"`
-	IndexedAt        string                                   `json:"indexedAt" cborgen:"indexedAt"`
-	InviteNote       *string                                  `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
-	InvitedBy        *comatprototypes.ServerDefs_InviteCode   `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
-	Invites          []*comatprototypes.ServerDefs_InviteCode `json:"invites,omitempty" cborgen:"invites,omitempty"`
-	InvitesDisabled  *bool                                    `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
-	Labels           []*comatprototypes.LabelDefs_Label       `json:"labels,omitempty" cborgen:"labels,omitempty"`
-	Moderation       *ModerationDefs_ModerationDetail         `json:"moderation" cborgen:"moderation"`
-	RelatedRecords   []*util.LexiconTypeDecoder               `json:"relatedRecords" cborgen:"relatedRecords"`
+	LexiconTypeID    string                                       `json:"$type,const=tools.ozone.moderation.defs#repoViewDetail" cborgen:"$type,const=tools.ozone.moderation.defs#repoViewDetail"`
+	DeactivatedAt    *string                                      `json:"deactivatedAt,omitempty" cborgen:"deactivatedAt,omitempty"`
+	Did              string                                       `json:"did" cborgen:"did"`
+	Email            *string                                      `json:"email,omitempty" cborgen:"email,omitempty"`
+	EmailConfirmedAt *string                                      `json:"emailConfirmedAt,omitempty" cborgen:"emailConfirmedAt,omitempty"`
+	Handle           string                                       `json:"handle" cborgen:"handle"`
+	IndexedAt        string                                       `json:"indexedAt" cborgen:"indexedAt"`
+	InviteNote       *string                                      `json:"inviteNote,omitempty" cborgen:"inviteNote,omitempty"`
+	InvitedBy        *comatprototypes.ServerDefs_InviteCode       `json:"invitedBy,omitempty" cborgen:"invitedBy,omitempty"`
+	Invites          []*comatprototypes.ServerDefs_InviteCode     `json:"invites,omitempty" cborgen:"invites,omitempty"`
+	InvitesDisabled  *bool                                        `json:"invitesDisabled,omitempty" cborgen:"invitesDisabled,omitempty"`
+	Labels           []*comatprototypes.LabelDefs_Label           `json:"labels,omitempty" cborgen:"labels,omitempty"`
+	Moderation       *ModerationDefs_ModerationDetail             `json:"moderation" cborgen:"moderation"`
+	RelatedRecords   []*util.LexiconTypeDecoder                   `json:"relatedRecords" cborgen:"relatedRecords"`
+	ThreatSignatures []*comatprototypes.AdminDefs_ThreatSignature `json:"threatSignatures,omitempty" cborgen:"threatSignatures,omitempty"`
 }
 
 // ModerationDefs_RepoViewNotFound is a "repoViewNotFound" in the tools.ozone.moderation.defs schema.

api/ozone/moderationqueryEvents.go

···
 //
 // addedLabels: If specified, only events where all of these labels were added are returned
 // addedTags: If specified, only events where all of these tags were added are returned
+// collections: If specified, only events where the subject belongs to the given collections will be returned. When subjectType is set to 'account', this will be ignored.
 // comment: If specified, only events with comments containing the keyword are returned
 // createdAfter: Retrieve events created after a given timestamp
 // createdBefore: Retrieve events created before a given timestamp
 // hasComment: If true, only events with comments are returned
-// includeAllUserRecords: If true, events on all record types (posts, lists, profile etc.) owned by the did are returned
+// includeAllUserRecords: If true, events on all record types (posts, lists, profile etc.) or records from given 'collections' param, owned by the did are returned.
 // removedLabels: If specified, only events where all of these labels were removed are returned
 // removedTags: If specified, only events where all of these tags were removed are returned
 // sortDirection: Sort direction for the events. Defaults to descending order of created at timestamp.
+// subjectType: If specified, only events where the subject is of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.
 // types: The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned.
-func ModerationQueryEvents(ctx context.Context, c *xrpc.Client, addedLabels []string, addedTags []string, comment string, createdAfter string, createdBefore string, createdBy string, cursor string, hasComment bool, includeAllUserRecords bool, limit int64, removedLabels []string, removedTags []string, reportTypes []string, sortDirection string, subject string, types []string) (*ModerationQueryEvents_Output, error) {
+func ModerationQueryEvents(ctx context.Context, c *xrpc.Client, addedLabels []string, addedTags []string, collections []string, comment string, createdAfter string, createdBefore string, createdBy string, cursor string, hasComment bool, includeAllUserRecords bool, limit int64, removedLabels []string, removedTags []string, reportTypes []string, sortDirection string, subject string, subjectType string, types []string) (*ModerationQueryEvents_Output, error) {
 	var out ModerationQueryEvents_Output
 
 	params := map[string]interface{}{
 		"addedLabels":           addedLabels,
 		"addedTags":             addedTags,
+		"collections":           collections,
 		"comment":               comment,
 		"createdAfter":          createdAfter,
 		"createdBefore":         createdBefore,
···
 		"reportTypes":           reportTypes,
 		"sortDirection":         sortDirection,
 		"subject":               subject,
+		"subjectType":           subjectType,
 		"types":                 types,
 	}
 	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.moderation.queryEvents", params, nil, &out); err != nil {

api/ozone/moderationqueryStatuses.go

···
 // ModerationQueryStatuses calls the XRPC method "tools.ozone.moderation.queryStatuses".
 //
 // appealed: Get subjects in unresolved appealed status
+// collections: If specified, subjects belonging to the given collections will be returned. When subjectType is set to 'account', this will be ignored.
 // comment: Search subjects by keyword from comments
-// includeAllUserRecords: All subjects belonging to the account specified in the 'subject' param will be returned.
+// includeAllUserRecords: All subjects, or subjects from given 'collections' param, belonging to the account specified in the 'subject' param will be returned.
 // includeMuted: By default, we don't include muted subjects in the results. Set this to true to include them.
 // lastReviewedBy: Get all subject statuses that were reviewed by a specific moderator
 // onlyMuted: When set to true, only muted subjects and reporters will be returned.
···
 // reviewedAfter: Search subjects reviewed after a given timestamp
 // reviewedBefore: Search subjects reviewed before a given timestamp
 // subject: The subject to get the status for.
+// subjectType: If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored.
 // takendown: Get subjects that were taken down
-func ModerationQueryStatuses(ctx context.Context, c *xrpc.Client, appealed bool, comment string, cursor string, excludeTags []string, ignoreSubjects []string, includeAllUserRecords bool, includeMuted bool, lastReviewedBy string, limit int64, onlyMuted bool, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, tags []string, takendown bool) (*ModerationQueryStatuses_Output, error) {
+func ModerationQueryStatuses(ctx context.Context, c *xrpc.Client, appealed bool, collections []string, comment string, cursor string, excludeTags []string, ignoreSubjects []string, includeAllUserRecords bool, includeMuted bool, lastReviewedBy string, limit int64, onlyMuted bool, reportedAfter string, reportedBefore string, reviewState string, reviewedAfter string, reviewedBefore string, sortDirection string, sortField string, subject string, subjectType string, tags []string, takendown bool) (*ModerationQueryStatuses_Output, error) {
 	var out ModerationQueryStatuses_Output
 
 	params := map[string]interface{}{
 		"appealed":              appealed,
+		"collections":           collections,
 		"comment":               comment,
 		"cursor":                cursor,
 		"excludeTags":           excludeTags,
···
 		"sortDirection":         sortDirection,
 		"sortField":             sortField,
 		"subject":               subject,
+		"subjectType":           subjectType,
 		"tags":                  tags,
 		"takendown":             takendown,
 	}

api/ozone/setaddValues.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.addValues
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetAddValues_Input is the input argument to a tools.ozone.set.addValues call.
+type SetAddValues_Input struct {
+	// name: Name of the set to add values to
+	Name string `json:"name" cborgen:"name"`
+	// values: Array of string values to add to the set
+	Values []string `json:"values" cborgen:"values"`
+}
+
+// SetAddValues calls the XRPC method "tools.ozone.set.addValues".
+func SetAddValues(ctx context.Context, c *xrpc.Client, input *SetAddValues_Input) error {
+	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.addValues", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/ozone/setdefs.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.defs
+
+// SetDefs_Set is a "set" in the tools.ozone.set.defs schema.
+type SetDefs_Set struct {
+	Description *string `json:"description,omitempty" cborgen:"description,omitempty"`
+	Name        string  `json:"name" cborgen:"name"`
+}
+
+// SetDefs_SetView is a "setView" in the tools.ozone.set.defs schema.
+type SetDefs_SetView struct {
+	CreatedAt   string  `json:"createdAt" cborgen:"createdAt"`
+	Description *string `json:"description,omitempty" cborgen:"description,omitempty"`
+	Name        string  `json:"name" cborgen:"name"`
+	SetSize     int64   `json:"setSize" cborgen:"setSize"`
+	UpdatedAt   string  `json:"updatedAt" cborgen:"updatedAt"`
+}

api/ozone/setdeleteSet.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.deleteSet
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetDeleteSet_Input is the input argument to a tools.ozone.set.deleteSet call.
+type SetDeleteSet_Input struct {
+	// name: Name of the set to delete
+	Name string `json:"name" cborgen:"name"`
+}
+
+// SetDeleteSet_Output is the output of a tools.ozone.set.deleteSet call.
+type SetDeleteSet_Output struct {
+}
+
+// SetDeleteSet calls the XRPC method "tools.ozone.set.deleteSet".
+func SetDeleteSet(ctx context.Context, c *xrpc.Client, input *SetDeleteSet_Input) (*SetDeleteSet_Output, error) {
+	var out SetDeleteSet_Output
+	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.deleteSet", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/ozone/setdeleteValues.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.deleteValues
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetDeleteValues_Input is the input argument to a tools.ozone.set.deleteValues call.
+type SetDeleteValues_Input struct {
+	// name: Name of the set to delete values from
+	Name string `json:"name" cborgen:"name"`
+	// values: Array of string values to delete from the set
+	Values []string `json:"values" cborgen:"values"`
+}
+
+// SetDeleteValues calls the XRPC method "tools.ozone.set.deleteValues".
+func SetDeleteValues(ctx context.Context, c *xrpc.Client, input *SetDeleteValues_Input) error {
+	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.deleteValues", nil, input, nil); err != nil {
+		return err
+	}
+
+	return nil
+}

api/ozone/setgetValues.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.getValues
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetGetValues_Output is the output of a tools.ozone.set.getValues call.
+type SetGetValues_Output struct {
+	Cursor *string          `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	Set    *SetDefs_SetView `json:"set" cborgen:"set"`
+	Values []string         `json:"values" cborgen:"values"`
+}
+
+// SetGetValues calls the XRPC method "tools.ozone.set.getValues".
+func SetGetValues(ctx context.Context, c *xrpc.Client, cursor string, limit int64, name string) (*SetGetValues_Output, error) {
+	var out SetGetValues_Output
+
+	params := map[string]interface{}{
+		"cursor": cursor,
+		"limit":  limit,
+		"name":   name,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.getValues", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/ozone/setquerySets.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.querySets
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetQuerySets_Output is the output of a tools.ozone.set.querySets call.
+type SetQuerySets_Output struct {
+	Cursor *string            `json:"cursor,omitempty" cborgen:"cursor,omitempty"`
+	Sets   []*SetDefs_SetView `json:"sets" cborgen:"sets"`
+}
+
+// SetQuerySets calls the XRPC method "tools.ozone.set.querySets".
+//
+// sortDirection: Defaults to ascending order of name field.
+func SetQuerySets(ctx context.Context, c *xrpc.Client, cursor string, limit int64, namePrefix string, sortBy string, sortDirection string) (*SetQuerySets_Output, error) {
+	var out SetQuerySets_Output
+
+	params := map[string]interface{}{
+		"cursor":        cursor,
+		"limit":         limit,
+		"namePrefix":    namePrefix,
+		"sortBy":        sortBy,
+		"sortDirection": sortDirection,
+	}
+	if err := c.Do(ctx, xrpc.Query, "", "tools.ozone.set.querySets", params, nil, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

api/ozone/setupsertSet.go

···
+// Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT.
+
+package ozone
+
+// schema: tools.ozone.set.upsertSet
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// SetUpsertSet calls the XRPC method "tools.ozone.set.upsertSet".
+func SetUpsertSet(ctx context.Context, c *xrpc.Client, input *SetDefs_Set) (*SetDefs_SetView, error) {
+	var out SetDefs_SetView
+	if err := c.Do(ctx, xrpc.Procedure, "application/json", "tools.ozone.set.upsertSet", nil, input, &out); err != nil {
+		return nil, err
+	}
+
+	return &out, nil
+}

atproto/data/cbor_gen.go

···
 		return fmt.Errorf("GenericRecord: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Type (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LegacyBlobSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (string) (string)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("BlobSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Ref (data.CIDLink) (struct)
 		case "ref":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

atproto/identity/identity.go

···
 	base := BaseDirectory{
 		PLCURL: DefaultPLCURL,
 		HTTPClient: http.Client{
-			Timeout: time.Second * 15,
+			Timeout: time.Second * 10,
+			Transport: &http.Transport{
+				// would want this around 100ms for services doing lots of handle resolution. Impacts PLC connections as well, but not too bad.
+				IdleConnTimeout: time.Millisecond * 1000,
+				MaxIdleConns:    100,
+			},
 		},
 		Resolver: net.Resolver{
 			Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
-				d := net.Dialer{Timeout: time.Second * 5}
+				d := net.Dialer{Timeout: time.Second * 3}
 				return d.DialContext(ctx, network, address)
 			},
 		},

automod/capture/testing.go

···
 	"io"
 	"os"
 
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
···
 	ctx := context.Background()
 
 	did := capture.AccountMeta.Identity.DID
+	handle := capture.AccountMeta.Identity.Handle.String()
 	dir := identity.NewMockDirectory()
 	dir.Insert(*capture.AccountMeta.Identity)
 	eng.Directory = &dir
 
 	// initial identity rules
-	eng.ProcessIdentityEvent(ctx, "new", did)
+	identEvent := comatproto.SyncSubscribeRepos_Identity{
+		Did:    did.String(),
+		Handle: &handle,
+		Seq:    12345,
+		Time:   syntax.DatetimeNow().String(),
+	}
+	eng.ProcessIdentityEvent(ctx, identEvent)
 
 	// all the post rules
 	for _, pr := range capture.PostRecords {

automod/consumer/doc.go

···
+// Code for consuming from atproto firehose and ozone event stream, pushing events in to automod engine.
+package consumer

automod/consumer/firehose.go

···
+package consumer
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"sync/atomic"
+	"time"
+
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/events/schedulers/autoscaling"
+	"github.com/bluesky-social/indigo/events/schedulers/parallel"
+	lexutil "github.com/bluesky-social/indigo/lex/util"
+
+	"github.com/bluesky-social/indigo/events"
+	"github.com/bluesky-social/indigo/repo"
+	"github.com/bluesky-social/indigo/repomgr"
+	"github.com/carlmjohnson/versioninfo"
+	"github.com/gorilla/websocket"
+	"github.com/redis/go-redis/v9"
+)
+
+// TODO: should probably make this not hepa-specific; or even configurable
+var firehoseCursorKey = "hepa/seq"
+
+type FirehoseConsumer struct {
+	Parallelism int
+	Logger      *slog.Logger
+	RedisClient *redis.Client
+	Engine      *automod.Engine
+	Host        string
+
+	// TODO: prefilter record collections; or predicate function?
+	// TODO: enable/disable event types; or predicate function?
+
+	// lastSeq is the most recent event sequence number we've received and begun to handle.
+	// This number is periodically persisted to redis, if redis is present.
+	// The value is best-effort (the stream handling itself is concurrent, so event numbers may not be monotonic),
+	// but nonetheless, you must use atomics when updating or reading this (to avoid data races).
+	lastSeq int64
+}
+
+func (fc *FirehoseConsumer) Run(ctx context.Context) error {
+
+	if fc.Engine == nil {
+		return fmt.Errorf("nil engine")
+	}
+
+	cur, err := fc.ReadLastCursor(ctx)
+	if err != nil {
+		return err
+	}
+
+	dialer := websocket.DefaultDialer
+	u, err := url.Parse(fc.Host)
+	if err != nil {
+		return fmt.Errorf("invalid Host URI: %w", err)
+	}
+	u.Path = "xrpc/com.atproto.sync.subscribeRepos"
+	if cur != 0 {
+		u.RawQuery = fmt.Sprintf("cursor=%d", cur)
+	}
+	fc.Logger.Info("subscribing to repo event stream", "upstream", fc.Host, "cursor", cur)
+	con, _, err := dialer.Dial(u.String(), http.Header{
+		"User-Agent": []string{fmt.Sprintf("hepa/%s", versioninfo.Short())},
+	})
+	if err != nil {
+		return fmt.Errorf("subscribing to firehose failed (dialing): %w", err)
+	}
+
+	rsc := &events.RepoStreamCallbacks{
+		RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {
+			atomic.StoreInt64(&fc.lastSeq, evt.Seq)
+			return fc.HandleRepoCommit(ctx, evt)
+		},
+		RepoIdentity: func(evt *comatproto.SyncSubscribeRepos_Identity) error {
+			atomic.StoreInt64(&fc.lastSeq, evt.Seq)
+			if err := fc.Engine.ProcessIdentityEvent(ctx, *evt); err != nil {
+				fc.Logger.Error("processing repo identity failed", "did", evt.Did, "seq", evt.Seq, "err", err)
+			}
+			return nil
+		},
+		RepoAccount: func(evt *comatproto.SyncSubscribeRepos_Account) error {
+			atomic.StoreInt64(&fc.lastSeq, evt.Seq)
+			if err := fc.Engine.ProcessAccountEvent(ctx, *evt); err != nil {
+				fc.Logger.Error("processing repo account failed", "did", evt.Did, "seq", evt.Seq, "err", err)
+			}
+			return nil
+		},
+		// NOTE: no longer process #handle events
+		// NOTE: no longer process #tombstone events
+	}
+
+	var scheduler events.Scheduler
+	if fc.Parallelism > 0 {
+		// use a fixed-parallelism scheduler if configured
+		scheduler = parallel.NewScheduler(
+			fc.Parallelism,
+			1000,
+			fc.Host,
+			rsc.EventHandler,
+		)
+		fc.Logger.Info("hepa scheduler configured", "scheduler", "parallel", "initial", fc.Parallelism)
+	} else {
+		// otherwise use auto-scaling scheduler
+		scaleSettings := autoscaling.DefaultAutoscaleSettings()
+		// start at higher parallelism (somewhat arbitrary)
+		scaleSettings.Concurrency = 4
+		scaleSettings.MaxConcurrency = 200
+		scheduler = autoscaling.NewScheduler(scaleSettings, fc.Host, rsc.EventHandler)
+		fc.Logger.Info("hepa scheduler configured", "scheduler", "autoscaling", "initial", scaleSettings.Concurrency, "max", scaleSettings.MaxConcurrency)
+	}
+
+	return events.HandleRepoStream(ctx, con, scheduler)
+}
+
+// NOTE: for now, this function basically never errors, just logs and returns nil. Should think through error processing better.
+func (fc *FirehoseConsumer) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Commit) error {
+
+	logger := fc.Logger.With("event", "commit", "did", evt.Repo, "rev", evt.Rev, "seq", evt.Seq)
+	logger.Debug("received commit event")
+
+	if evt.TooBig {
+		logger.Warn("skipping tooBig events for now")
+		return nil
+	}
+
+	did, err := syntax.ParseDID(evt.Repo)
+	if err != nil {
+		logger.Error("bad DID syntax in event", "err", err)
+		return nil
+	}
+
+	rr, err := repo.ReadRepoFromCar(ctx, bytes.NewReader(evt.Blocks))
+	if err != nil {
+		logger.Error("failed to read repo from car", "err", err)
+		return nil
+	}
+
+	for _, op := range evt.Ops {
+		logger = logger.With("eventKind", op.Action, "path", op.Path)
+		collection, rkey, err := splitRepoPath(op.Path)
+		if err != nil {
+			logger.Error("invalid path in repo op")
+			return nil
+		}
+
+		ek := repomgr.EventKind(op.Action)
+		switch ek {
+		case repomgr.EvtKindCreateRecord, repomgr.EvtKindUpdateRecord:
+			// read the record bytes from blocks, and verify CID
+			rc, recCBOR, err := rr.GetRecordBytes(ctx, op.Path)
+			if err != nil {
+				logger.Error("reading record from event blocks (CAR)", "err", err)
+				break
+			}
+			if op.Cid == nil || lexutil.LexLink(rc) != *op.Cid {
+				logger.Error("mismatch between commit op CID and record block", "recordCID", rc, "opCID", op.Cid)
+				break
+			}
+			var action string
+			switch ek {
+			case repomgr.EvtKindCreateRecord:
+				action = automod.CreateOp
+			case repomgr.EvtKindUpdateRecord:
+				action = automod.UpdateOp
+			default:
+				logger.Error("impossible event kind", "kind", ek)
+				break
+			}
+			recCID := syntax.CID(op.Cid.String())
+			op := automod.RecordOp{
+				Action:     action,
+				DID:        did,
+				Collection: collection,
+				RecordKey:  rkey,
+				CID:        &recCID,
+				RecordCBOR: *recCBOR,
+			}
+			err = fc.Engine.ProcessRecordOp(ctx, op)
+			if err != nil {
+				logger.Error("engine failed to process record", "err", err)
+				continue
+			}
+		case repomgr.EvtKindDeleteRecord:
+			op := automod.RecordOp{
+				Action:     automod.DeleteOp,
+				DID:        did,
+				Collection: collection,
+				RecordKey:  rkey,
+				CID:        nil,
+				RecordCBOR: nil,
+			}
+			err = fc.Engine.ProcessRecordOp(ctx, op)
+			if err != nil {
+				logger.Error("engine failed to process record", "err", err)
+				continue
+			}
+		default:
+			// TODO: should this be an error?
+		}
+	}
+
+	return nil
+}
+
+func (fc *FirehoseConsumer) ReadLastCursor(ctx context.Context) (int64, error) {
+	// if redis isn't configured, just skip
+	if fc.RedisClient == nil {
+		fc.Logger.Info("redis not configured, skipping cursor read")
+		return 0, nil
+	}
+
+	val, err := fc.RedisClient.Get(ctx, firehoseCursorKey).Int64()
+	if err == redis.Nil {
+		fc.Logger.Info("no pre-existing cursor in redis")
+		return 0, nil
+	} else if err != nil {
+		return 0, err
+	}
+	fc.Logger.Info("successfully found prior subscription cursor seq in redis", "seq", val)
+	return val, nil
+}
+
+func (fc *FirehoseConsumer) PersistCursor(ctx context.Context) error {
+	// if redis isn't configured, just skip
+	if fc.RedisClient == nil {
+		return nil
+	}
+	lastSeq := atomic.LoadInt64(&fc.lastSeq)
+	if lastSeq <= 0 {
+		return nil
+	}
+	err := fc.RedisClient.Set(ctx, firehoseCursorKey, lastSeq, 14*24*time.Hour).Err()
+	return err
+}
+
+// this method runs in a loop, persisting the current cursor state every 5 seconds
+func (fc *FirehoseConsumer) RunPersistCursor(ctx context.Context) error {
+
+	// if redis isn't configured, just skip
+	if fc.RedisClient == nil {
+		return nil
+	}
+	ticker := time.NewTicker(5 * time.Second)
+	for {
+		select {
+		case <-ctx.Done():
+			lastSeq := atomic.LoadInt64(&fc.lastSeq)
+			if lastSeq >= 1 {
+				fc.Logger.Info("persisting final cursor seq value", "seq", lastSeq)
+				err := fc.PersistCursor(ctx)
+				if err != nil {
+					fc.Logger.Error("failed to persist cursor", "err", err, "seq", lastSeq)
+				}
+			}
+			return nil
+		case <-ticker.C:
+			lastSeq := atomic.LoadInt64(&fc.lastSeq)
+			if lastSeq >= 1 {
+				err := fc.PersistCursor(ctx)
+				if err != nil {
+					fc.Logger.Error("failed to persist cursor", "err", err, "seq", lastSeq)
+				}
+			}
+		}
+	}
+}

automod/consumer/ozone.go

···
+package consumer
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"sync/atomic"
+	"time"
+
+	toolsozone "github.com/bluesky-social/indigo/api/ozone"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/xrpc"
+
+	"github.com/redis/go-redis/v9"
+)
+
+// TODO: should probably make this not hepa-specific; or even configurable
+var ozoneCursorKey = "hepa/ozoneTimestamp"
+
+type OzoneConsumer struct {
+	Logger      *slog.Logger
+	RedisClient *redis.Client
+	OzoneClient *xrpc.Client
+	Engine      *automod.Engine
+
+	// same as lastSeq, but for Ozone timestamp cursor. the value is a string.
+	lastCursor atomic.Value
+}
+
+func (oc *OzoneConsumer) Run(ctx context.Context) error {
+
+	if oc.Engine == nil {
+		return fmt.Errorf("nil engine")
+	}
+	if oc.OzoneClient == nil {
+		return fmt.Errorf("nil ozoneclient")
+	}
+
+	cur, err := oc.ReadLastCursor(ctx)
+	if err != nil {
+		return err
+	}
+
+	if cur == "" {
+		cur = syntax.DatetimeNow().String()
+	}
+	since, err := syntax.ParseDatetime(cur)
+	if err != nil {
+		return err
+	}
+
+	oc.Logger.Info("subscribing to ozone event log", "upstream", oc.OzoneClient.Host, "cursor", cur, "since", since)
+	var limit int64 = 50
+	period := time.Second * 5
+
+	for {
+		me, err := toolsozone.ModerationQueryEvents(
+			ctx,
+			oc.OzoneClient,
+			nil,            // addedLabels []string
+			nil,            // addedTags []string
+			nil,            // collections []string
+			"",             // comment string
+			since.String(), // createdAfter string
+			"",             // createdBefore string
+			"",             // createdBy string
+			"",             // cursor string
+			false,          // hasComment bool
+			true,           // includeAllUserRecords bool
+			limit,          // limit int64
+			nil,            // removedLabels []string
+			nil,            // removedTags []string
+			nil,            // reportTypes []string
+			"asc",          // sortDirection string
+			"",             // subject string
+			"",             // subjectType string
+			nil,            // types []string
+		)
+		if err != nil {
+			oc.Logger.Warn("ozone query events failed; sleeping then will retrying", "err", err, "period", period.String())
+			time.Sleep(period)
+			continue
+		}
+
+		// track if the response contained anything new
+		anyNewEvents := false
+		for _, evt := range me.Events {
+			createdAt, err := syntax.ParseDatetime(evt.CreatedAt)
+			if err != nil {
+				return fmt.Errorf("invalid time format for ozone 'createdAt': %w", err)
+			}
+			// skip if the timestamp is the exact same
+			if createdAt == since {
+				continue
+			}
+			anyNewEvents = true
+			// TODO: is there a race condition here?
+			if !createdAt.Time().After(since.Time()) {
+				oc.Logger.Error("out of order ozone event", "createdAt", createdAt, "since", since)
+				return fmt.Errorf("out of order ozone event")
+			}
+			if err = oc.HandleOzoneEvent(ctx, evt); err != nil {
+				oc.Logger.Error("failed to process ozone event", "event", evt)
+			}
+			since = createdAt
+			oc.lastCursor.Store(since.String())
+		}
+		if !anyNewEvents {
+			oc.Logger.Debug("... ozone poller sleeping", "period", period.String())
+			time.Sleep(period)
+		}
+	}
+}
+
+func (oc *OzoneConsumer) HandleOzoneEvent(ctx context.Context, eventView *toolsozone.ModerationDefs_ModEventView) error {
+
+	oc.Logger.Debug("received ozone event", "eventID", eventView.Id, "createdAt", eventView.CreatedAt)
+
+	if err := oc.Engine.ProcessOzoneEvent(ctx, eventView); err != nil {
+		oc.Logger.Error("engine failed to process ozone event", "err", err)
+	}
+	return nil
+}
+
+func (oc *OzoneConsumer) ReadLastCursor(ctx context.Context) (string, error) {
+	// if redis isn't configured, just skip
+	if oc.RedisClient == nil {
+		oc.Logger.Info("redis not configured, skipping ozone cursor read")
+		return "", nil
+	}
+
+	val, err := oc.RedisClient.Get(ctx, ozoneCursorKey).Result()
+	if err == redis.Nil || val == "" {
+		oc.Logger.Info("no pre-existing ozone cursor in redis")
+		return "", nil
+	} else if err != nil {
+		return "", err
+	}
+	oc.Logger.Info("successfully found prior ozone offset timestamp in redis", "cursor", val)
+	return val, nil
+}
+
+func (oc *OzoneConsumer) PersistCursor(ctx context.Context) error {
+	// if redis isn't configured, just skip
+	if oc.RedisClient == nil {
+		return nil
+	}
+	lastCursor := oc.lastCursor.Load()
+	if lastCursor == nil || lastCursor == "" {
+		return nil
+	}
+	err := oc.RedisClient.Set(ctx, ozoneCursorKey, lastCursor, 14*24*time.Hour).Err()
+	return err
+}
+
+// this method runs in a loop, persisting the current cursor state every 5 seconds
+func (oc *OzoneConsumer) RunPersistCursor(ctx context.Context) error {
+
+	// if redis isn't configured, just skip
+	if oc.RedisClient == nil {
+		return nil
+	}
+	ticker := time.NewTicker(5 * time.Second)
+	for {
+		select {
+		case <-ctx.Done():
+			lastCursor := oc.lastCursor.Load()
+			if lastCursor != nil && lastCursor != "" {
+				oc.Logger.Info("persisting final ozone cursor timestamp", "cursor", lastCursor)
+				err := oc.PersistCursor(ctx)
+				if err != nil {
+					oc.Logger.Error("failed to persist ozone cursor", "err", err, "cursor", lastCursor)
+				}
+			}
+			return nil
+		case <-ticker.C:
+			lastCursor := oc.lastCursor.Load()
+			if lastCursor != nil && lastCursor != "" {
+				err := oc.PersistCursor(ctx)
+				if err != nil {
+					oc.Logger.Error("failed to persist ozone cursor", "err", err, "cursor", lastCursor)
+				}
+			}
+		}
+	}
+}

automod/consumer/util.go

···
+package consumer
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+)
+
+// TODO: move this to a "ParsePath" helper in syntax package?
+func splitRepoPath(path string) (syntax.NSID, syntax.RecordKey, error) {
+	parts := strings.SplitN(path, "/", 3)
+	if len(parts) != 2 {
+		return "", "", fmt.Errorf("invalid record path: %s", path)
+	}
+	collection, err := syntax.ParseNSID(parts[0])
+	if err != nil {
+		return "", "", err
+	}
+	rkey, err := syntax.ParseRecordKey(parts[1])
+	if err != nil {
+		return "", "", err
+	}
+	return collection, rkey, nil
+}

automod/engine/account_meta.go

···
 
 type ProfileSummary struct {
 	HasAvatar   bool
+	AvatarCid   *string
+	BannerCid   *string
 	Description *string
 	DisplayName *string
 }
 
+// opaque fingerprints for correlating abusive accounts
+type AbuseSignature struct {
+	Property string
+	Value    string
+}
+
 type AccountPrivate struct {
 	Email          string
 	EmailConfirmed bool
 	IndexedAt      *time.Time
 	AccountTags    []string
 	// ReviewState will be one of ReviewStateEscalated, ReviewStateOpen, ReviewStateClosed, ReviewStateNone, or "" (unknown)
-	ReviewState string
-	Appealed    bool
+	ReviewState     string
+	Appealed        bool
+	AbuseSignatures []AbuseSignature
 }

automod/engine/cid_from_cdn_test.go

···
+package engine
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestCidFromCdnUrl(t *testing.T) {
+	assert := assert.New(t)
+
+	fixCid := "abcdefghijk"
+
+	fixtures := []struct {
+		url string
+		cid *string
+	}{
+		{
+			url: "https://cdn.bsky.app/img/avatar/plain/did:plc:abc123/abcdefghijk@jpeg",
+			cid: &fixCid,
+		},
+		{
+			url: "https://cdn.bsky.app/img/feed_fullsize/plain/did:plc:abc123/abcdefghijk@jpeg",
+			cid: &fixCid,
+		},
+		{
+			url: "https://cdn.bsky.app/img/feed_fullsize",
+			cid: nil,
+		},
+		{
+			url: "https://cdn.bsky.app/img/feed_fullsize/plain/did:plc:abc123/abcdefghijk",
+			cid: &fixCid,
+		},
+		{
+			url: "https://cdn.asky.app/img/feed_fullsize/plain/did:plc:abc123/abcdefghijk@jpeg",
+			cid: nil,
+		},
+	}
+
+	for _, fix := range fixtures {
+		assert.Equal(fix.cid, cidFromCdnUrl(&fix.url))
+	}
+}

automod/engine/context.go

···
 	return out
 }
 
+// Returns a pointer to the underlying automod engine. This usually should NOT be used in rules.
+//
+// This is an escape hatch for hacking on the system before features get fully integerated in to the content API surface. The Engine API is not stable.
+func (c *BaseContext) InternalEngine() *Engine {
+	return c.engine
+}
+
 func NewAccountContext(ctx context.Context, eng *Engine, meta AccountMeta) AccountContext {
 	return AccountContext{
 		BaseContext: BaseContext{
···
 	c.effects.AddAccountLabel(val)
 }
 
+func (c *AccountContext) AddAccountTag(val string) {
+	c.effects.AddAccountTag(val)
+}
+
 func (c *AccountContext) ReportAccount(reason, comment string) {
 	c.effects.ReportAccount(reason, comment)
 }
···
 
 func (c *RecordContext) AddRecordLabel(val string) {
 	c.effects.AddRecordLabel(val)
+}
+
+func (c *RecordContext) AddRecordTag(val string) {
+	c.effects.AddRecordTag(val)
 }
 
 func (c *RecordContext) ReportRecord(reason, comment string) {

automod/engine/effects.go

···
 	CounterDistinctIncrements []CounterDistinctRef // TODO: better variable names
 	// Label values which should be applied to the overall account, as a result of rule execution.
 	AccountLabels []string
-	// Moderation flags (similar to labels, but private) which should be applied to the overall account, as a result of rule execution.
+	// Moderation tags (similar to labels, but private) which should be applied to the overall account, as a result of rule execution.
+	AccountTags []string
+	// automod flags (metadata) which should be applied to the account as a result of rule execution.
 	AccountFlags []string
 	// Reports which should be filed against this account, as a result of rule execution.
 	AccountReports []ModReport
···
 	AccountAcknowledge bool
 	// Same as "AccountLabels", but at record-level
 	RecordLabels []string
+	// Same as "AccountTags", but at record-level
+	RecordTags []string
 	// Same as "AccountFlags", but at record-level
 	RecordFlags []string
 	// Same as "AccountReports", but at record-level
···
 	e.AccountLabels = append(e.AccountLabels, val)
 }
 
+// Enqueues the provided label (string value) to be added to the account at the end of rule processing.
+func (e *Effects) AddAccountTag(val string) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	for _, v := range e.AccountTags {
+		if v == val {
+			return
+		}
+	}
+	e.AccountTags = append(e.AccountTags, val)
+}
+
 // Enqueues the provided flag (string value) to be recorded (in the Engine's flagstore) at the end of rule processing.
 func (e *Effects) AddAccountFlag(val string) {
 	e.mu.Lock()
···
 		}
 	}
 	e.RecordLabels = append(e.RecordLabels, val)
+}
+
+// Enqueues the provided tag (string value) to be added to the record at the end of rule processing.
+func (e *Effects) AddRecordTag(val string) {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+	for _, v := range e.RecordTags {
+		if v == val {
+			return
+		}
+	}
+	e.RecordTags = append(e.RecordTags, val)
 }
 
 // Enqueues the provided flag (string value) to be recorded (in the Engine's flagstore) at the end of rule processing.

automod/engine/engine.go

···
 	"net/http"
 	"time"
 
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod/cachestore"
···
 	AdminClient *xrpc.Client
 	// used to fetch blobs from upstream PDS instances
 	BlobClient *http.Client
+
+	// internal configuration
+	Config EngineConfig
+}
+
+type EngineConfig struct {
+	// if enabled, account metadata is not hydrated for every event by default
+	SkipAccountMeta bool
 }
 
-// Entrypoint for external code pushing arbitrary identity events in to the engine.
+// Entrypoint for external code pushing #identity events in to the engine.
 //
 // This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.
-func (eng *Engine) ProcessIdentityEvent(ctx context.Context, typ string, did syntax.DID) error {
+func (eng *Engine) ProcessIdentityEvent(ctx context.Context, evt comatproto.SyncSubscribeRepos_Identity) error {
 	eventProcessCount.WithLabelValues("identity").Inc()
 	start := time.Now()
 	defer func() {
···
 		eventProcessDuration.WithLabelValues("identity").Observe(duration.Seconds())
 	}()
 
+	did, err := syntax.ParseDID(evt.Did)
+	if err != nil {
+		return fmt.Errorf("bad DID in repo #identity event (%s): %w", evt.Did, err)
+	}
+
 	// similar to an HTTP server, we want to recover any panics from rule execution
 	defer func() {
 		if r := recover(); r != nil {
-			eng.Logger.Error("automod event execution exception", "err", r, "did", did, "type", typ)
+			eng.Logger.Error("automod event execution exception", "err", r, "did", did, "type", "identity")
 			eventErrorCount.WithLabelValues("identity").Inc()
 		}
 	}()
···
 	if err := eng.PurgeAccountCaches(ctx, did); err != nil {
 		eng.Logger.Error("failed to purge identity cache; identity rule may not run correctly", "err", err)
 	}
+	// TODO(bnewbold): if it was a tombstone, this might fail
 	ident, err := eng.Directory.LookupDID(ctx, did)
 	if err != nil {
 		eventErrorCount.WithLabelValues("identity").Inc()
···
 		return fmt.Errorf("identity not found for DID: %s", did.String())
 	}
 
-	am, err := eng.GetAccountMeta(ctx, ident)
-	if err != nil {
-		eventErrorCount.WithLabelValues("identity").Inc()
-		return fmt.Errorf("failed to fetch account metadata: %w", err)
+	var am *AccountMeta
+	if !eng.Config.SkipAccountMeta {
+		am, err = eng.GetAccountMeta(ctx, ident)
+		if err != nil {
+			eventErrorCount.WithLabelValues("identity").Inc()
+			return fmt.Errorf("failed to fetch account metadata: %w", err)
+		}
+	} else {
+		am = &AccountMeta{
+			Identity: ident,
+			Profile:  ProfileSummary{},
+		}
 	}
 	ac := NewAccountContext(ctx, eng, *am)
 	if err := eng.Rules.CallIdentityRules(&ac); err != nil {
···
 	return nil
 }
 
+// Entrypoint for external code pushing #account events in to the engine.
+//
+// This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.
+func (eng *Engine) ProcessAccountEvent(ctx context.Context, evt comatproto.SyncSubscribeRepos_Account) error {
+	eventProcessCount.WithLabelValues("account").Inc()
+	start := time.Now()
+	defer func() {
+		duration := time.Since(start)
+		eventProcessDuration.WithLabelValues("account").Observe(duration.Seconds())
+	}()
+
+	did, err := syntax.ParseDID(evt.Did)
+	if err != nil {
+		return fmt.Errorf("bad DID in repo #account event (%s): %w", evt.Did, err)
+	}
+
+	// similar to an HTTP server, we want to recover any panics from rule execution
+	defer func() {
+		if r := recover(); r != nil {
+			eng.Logger.Error("automod event execution exception", "err", r, "did", did, "type", "account")
+			eventErrorCount.WithLabelValues("account").Inc()
+		}
+	}()
+	ctx, cancel := context.WithTimeout(ctx, identityEventTimeout)
+	defer cancel()
+
+	// first purge any caches; we need to re-resolve from scratch on account updates
+	if err := eng.PurgeAccountCaches(ctx, did); err != nil {
+		eng.Logger.Error("failed to purge account cache; account rule may not run correctly", "err", err)
+	}
+	// TODO(bnewbold): if it was a tombstone, this might fail
+	ident, err := eng.Directory.LookupDID(ctx, did)
+	if err != nil {
+		eventErrorCount.WithLabelValues("account").Inc()
+		return fmt.Errorf("resolving identity: %w", err)
+	}
+	if ident == nil {
+		eventErrorCount.WithLabelValues("account").Inc()
+		return fmt.Errorf("identity not found for DID: %s", did.String())
+	}
+
+	var am *AccountMeta
+	if !eng.Config.SkipAccountMeta {
+		am, err = eng.GetAccountMeta(ctx, ident)
+		if err != nil {
+			eventErrorCount.WithLabelValues("identity").Inc()
+			return fmt.Errorf("failed to fetch account metadata: %w", err)
+		}
+	} else {
+		am = &AccountMeta{
+			Identity: ident,
+			Profile:  ProfileSummary{},
+		}
+	}
+	ac := NewAccountContext(ctx, eng, *am)
+	if err := eng.Rules.CallAccountRules(&ac); err != nil {
+		eventErrorCount.WithLabelValues("account").Inc()
+		return fmt.Errorf("rule execution failed: %w", err)
+	}
+	eng.CanonicalLogLineAccount(&ac)
+	if err := eng.persistAccountModActions(&ac); err != nil {
+		eventErrorCount.WithLabelValues("account").Inc()
+		return fmt.Errorf("failed to persist actions for account event: %w", err)
+	}
+	if err := eng.persistCounters(ctx, ac.effects); err != nil {
+		eventErrorCount.WithLabelValues("account").Inc()
+		return fmt.Errorf("failed to persist counters for account event: %w", err)
+	}
+	return nil
+}
+
 // Entrypoint for external code pushing repository updates. A simple repo commit results in multiple calls.
 //
 // This method can be called concurrently, though cached state may end up inconsistent if multiple events for the same account (DID) are processed in parallel.
···
 		return fmt.Errorf("identity not found for DID: %s", op.DID)
 	}
 
-	am, err := eng.GetAccountMeta(ctx, ident)
-	if err != nil {
-		eventErrorCount.WithLabelValues("record").Inc()
-		return fmt.Errorf("failed to fetch account metadata: %w", err)
+	var am *AccountMeta
+	if !eng.Config.SkipAccountMeta {
+		am, err = eng.GetAccountMeta(ctx, ident)
+		if err != nil {
+			eventErrorCount.WithLabelValues("identity").Inc()
+			return fmt.Errorf("failed to fetch account metadata: %w", err)
+		}
+	} else {
+		am = &AccountMeta{
+			Identity: ident,
+			Profile:  ProfileSummary{},
+		}
 	}
 	rc := NewRecordContext(ctx, eng, *am, op)
 	rc.Logger.Debug("processing record")
···
 	c.Logger.Info("canonical-event-line",
 		"accountLabels", c.effects.AccountLabels,
 		"accountFlags", c.effects.AccountFlags,
+		"accountTags", c.effects.AccountTags,
 		"accountTakedown", c.effects.AccountTakedown,
 		"accountReports", len(c.effects.AccountReports),
 	)
···
 	c.Logger.Info("canonical-event-line",
 		"accountLabels", c.effects.AccountLabels,
 		"accountFlags", c.effects.AccountFlags,
+		"accountTags", c.effects.AccountTags,
 		"accountTakedown", c.effects.AccountTakedown,
 		"accountReports", len(c.effects.AccountReports),
 		"recordLabels", c.effects.RecordLabels,
 		"recordFlags", c.effects.RecordFlags,
+		"recordTags", c.effects.RecordTags,
 		"recordTakedown", c.effects.RecordTakedown,
 		"recordReports", len(c.effects.RecordReports),
 	)
···
 	c.Logger.Info("canonical-event-line",
 		"accountLabels", c.effects.AccountLabels,
 		"accountFlags", c.effects.AccountFlags,
+		"accountTags", c.effects.AccountTags,
 		"accountTakedown", c.effects.AccountTakedown,
 		"accountReports", len(c.effects.AccountReports),
 		"reject", c.effects.RejectEvent,

automod/engine/fetch_account_meta.go

···
 
 	// fallback in case client wasn't configured (eg, testing)
 	if e.BskyClient == nil {
-		logger.Warn("skipping account meta hydration")
+		logger.Debug("skipping account meta hydration")
 		am := AccountMeta{
 			Identity: ident,
 			Profile:  ProfileSummary{},
···
 	// most common cause of this is a race between automod and ozone/appview for new accounts. just sleep a couple seconds and retry!
 	var xrpcError *xrpc.Error
 	if err != nil && errors.As(err, &xrpcError) && (xrpcError.StatusCode == 400 || xrpcError.StatusCode == 404) {
-		logger.Info("account profile lookup initially failed (from bsky appview), will retry", "err", err, "sleepDuration", newAccountRetryDuration)
+		logger.Debug("account profile lookup initially failed (from bsky appview), will retry", "err", err, "sleepDuration", newAccountRetryDuration)
 		time.Sleep(newAccountRetryDuration)
 		pv, err = appbsky.ActorGetProfile(ctx, e.BskyClient, ident.DID.String())
 	}
···
 
 	am.Profile = ProfileSummary{
 		HasAvatar:   pv.Avatar != nil,
+		AvatarCid:   cidFromCdnUrl(pv.Avatar),
+		BannerCid:   cidFromCdnUrl(pv.Banner),
 		Description: pv.Description,
 		DisplayName: pv.DisplayName,
 	}
···
 						ap.ReviewState = ReviewStateNone
 					}
 				}
+			}
+			if rd.ThreatSignatures != nil || len(rd.ThreatSignatures) > 0 {
+				asigs := make([]AbuseSignature, len(rd.ThreatSignatures))
+				for i, sig := range rd.ThreatSignatures {
+					asigs[i] = AbuseSignature{Property: sig.Property, Value: sig.Value}
+				}
+				ap.AbuseSignatures = asigs
 			}
 			am.Private = &ap
 		}

automod/engine/metrics.go

···
 	Help: "Number of new labels persisted",
 }, []string{"type", "val"})
 
+var actionNewTagCount = promauto.NewCounterVec(prometheus.CounterOpts{
+	Name: "automod_new_action_tags",
+	Help: "Number of new tags persisted",
+}, []string{"type", "val"})
+
 var actionNewFlagCount = promauto.NewCounterVec(prometheus.CounterOpts{
 	Name: "automod_new_action_flags",
 	Help: "Number of new flags persisted",

automod/engine/persist.go

···
 	return nil
 }
 
-// Persists account-level moderation actions: new labels, new flags, new takedowns, and reports.
+// Persists account-level moderation actions: new labels, new tags, new flags, new takedowns, and reports.
 //
 // If necessary, will "purge" identity and account caches, so that state updates will be picked up for subsequent events.
 //
···
 
 	// de-dupe actions
 	newLabels := dedupeLabelActions(c.effects.AccountLabels, c.Account.AccountLabels, c.Account.AccountNegatedLabels)
+	existingTags := []string{}
+	if c.Account.Private != nil {
+		existingTags = c.Account.Private.AccountTags
+	}
+	newTags := dedupeTagActions(c.effects.AccountTags, existingTags)
 	newFlags := dedupeFlagActions(c.effects.AccountFlags, c.Account.AccountFlags)
 
 	// don't report the same account multiple times on the same day for the same reason. this is a quick check; we also query the mod service API just before creating the report.
···
 		}
 	}
 
-	anyModActions := newTakedown || newEscalation || newAcknowledge || len(newLabels) > 0 || len(newFlags) > 0 || len(newReports) > 0
+	anyModActions := newTakedown || newEscalation || newAcknowledge || len(newLabels) > 0 || len(newTags) > 0 || len(newFlags) > 0 || len(newReports) > 0
 	if anyModActions && eng.Notifier != nil {
 		for _, srv := range dedupeStrings(c.effects.NotifyServices) {
 			if err := eng.Notifier.SendAccount(ctx, srv, c); err != nil {
···
 	xrpcc := eng.OzoneClient
 
 	if len(newLabels) > 0 {
-		c.Logger.Info("labeling record", "newLabels", newLabels)
+		c.Logger.Info("labeling account", "newLabels", newLabels)
 		for _, val := range newLabels {
 			// note: WithLabelValues is a prometheus label, not an atproto label
 			actionNewLabelCount.WithLabelValues("account", val).Inc()
···
 		}
 	}
 
+	if len(newTags) > 0 {
+		c.Logger.Info("tagging account", "newTags", newTags)
+		for _, val := range newTags {
+			// note: WithLabelValues is a prometheus label, not an atproto label
+			actionNewTagCount.WithLabelValues("account", val).Inc()
+		}
+		comment := "[automod]: auto-tagging account"
+		_, err := toolsozone.ModerationEmitEvent(ctx, xrpcc, &toolsozone.ModerationEmitEvent_Input{
+			CreatedBy: xrpcc.Auth.Did,
+			Event: &toolsozone.ModerationEmitEvent_Input_Event{
+				ModerationDefs_ModEventTag: &toolsozone.ModerationDefs_ModEventTag{
+					Add:     newTags,
+					Remove:  []string{},
+					Comment: &comment,
+				},
+			},
+			Subject: &toolsozone.ModerationEmitEvent_Input_Subject{
+				AdminDefs_RepoRef: &comatproto.AdminDefs_RepoRef{
+					Did: c.Account.Identity.DID.String(),
+				},
+			},
+		})
+		if err != nil {
+			c.Logger.Error("failed to create account tags", "err", err)
+		}
+	}
+
 	// reports are additionally de-duped when persisting the action, so track with a flag
 	createdReports := false
 	for _, mr := range newReports {
···
 		}
 	}
 
-	needCachePurge := newTakedown || newEscalation || newAcknowledge || len(newLabels) > 0 || len(newFlags) > 0 || createdReports
+	needCachePurge := newTakedown || newEscalation || newAcknowledge || len(newLabels) > 0 || len(newTags) > 0 || len(newFlags) > 0 || createdReports
 	if needCachePurge {
 		return eng.PurgeAccountCaches(ctx, c.Account.Identity.DID)
 	}
···
 	return nil
 }
 
-// Persists some record-level state: labels, takedowns, reports.
+// Persists some record-level state: labels, tags, takedowns, reports.
 //
 // NOTE: this method currently does *not* persist record-level flags to any storage, and does not de-dupe most actions, on the assumption that the record is new (from firehose) and has no existing mod state.
 func (eng *Engine) persistRecordModActions(c *RecordContext) error {
···
 
 	atURI := c.RecordOp.ATURI().String()
 	newLabels := dedupeStrings(c.effects.RecordLabels)
-	if len(newLabels) > 0 && eng.OzoneClient != nil {
+	newTags := dedupeStrings(c.effects.RecordTags)
+	if (len(newLabels) > 0 || len(newTags) > 0) && eng.OzoneClient != nil {
+		// fetch existing record labels, tags, etc
 		rv, err := toolsozone.ModerationGetRecord(ctx, eng.OzoneClient, c.RecordOp.CID.String(), c.RecordOp.ATURI().String())
 		if err != nil {
 			// NOTE: there is a frequent 4xx error here from Ozone because this record has not been indexed yet
···
 			}
 			existingLabels = dedupeStrings(existingLabels)
 			negLabels = dedupeStrings(negLabels)
-			// fetch existing record labels
 			newLabels = dedupeLabelActions(newLabels, existingLabels, negLabels)
+			existingTags := []string{}
+			if rv.Moderation != nil && rv.Moderation.SubjectStatus != nil && rv.Moderation.SubjectStatus.Tags != nil {
+				existingTags = rv.Moderation.SubjectStatus.Tags
+			}
+			newTags = dedupeTagActions(newTags, existingTags)
 		}
 	}
+
 	newFlags := dedupeStrings(c.effects.RecordFlags)
 	if len(newFlags) > 0 {
 		// fetch existing flags, and de-dupe
···
 		return fmt.Errorf("circuit-breaking acknowledge: %w", err)
 	}
 
-	if newEscalation || newAcknowledge || newTakedown || len(newLabels) > 0 || len(newFlags) > 0 || len(newReports) > 0 {
+	if newEscalation || newAcknowledge || newTakedown || len(newLabels) > 0 || len(newTags) > 0 || len(newFlags) > 0 || len(newReports) > 0 {
 		if eng.Notifier != nil {
 			for _, srv := range dedupeStrings(c.effects.NotifyServices) {
 				if err := eng.Notifier.SendRecord(ctx, srv, c); err != nil {
···
 	}
 
 	// exit early
-	if !newAcknowledge && !newEscalation && !newTakedown && len(newLabels) == 0 && len(newReports) == 0 {
+	if !newAcknowledge && !newEscalation && !newTakedown && len(newLabels) == 0 && len(newTags) == 0 && len(newReports) == 0 {
 		return nil
 	}
 
···
 		})
 		if err != nil {
 			c.Logger.Error("failed to create record label", "err", err)
+		}
+	}
+
+	if len(newTags) > 0 {
+		c.Logger.Info("tagging record", "newTags", newTags)
+		for _, val := range newTags {
+			// note: WithLabelValues is a prometheus label, not an atproto label
+			actionNewTagCount.WithLabelValues("record", val).Inc()
+		}
+		comment := "[automod]: auto-tagging record"
+		_, err := toolsozone.ModerationEmitEvent(ctx, xrpcc, &toolsozone.ModerationEmitEvent_Input{
+			CreatedBy: xrpcc.Auth.Did,
+			Event: &toolsozone.ModerationEmitEvent_Input_Event{
+				ModerationDefs_ModEventTag: &toolsozone.ModerationDefs_ModEventTag{
+					Add:     newTags,
+					Remove:  []string{},
+					Comment: &comment,
+				},
+			},
+			Subject: &toolsozone.ModerationEmitEvent_Input_Subject{
+				RepoStrongRef: &strongRef,
+			},
+		})
+		if err != nil {
+			c.Logger.Error("failed to create record tag", "err", err)
 		}
 	}
 

automod/engine/persisthelpers.go

···
 	return newLabels
 }
 
+func dedupeTagActions(tags, existing []string) []string {
+	newTags := []string{}
+	for _, val := range dedupeStrings(tags) {
+		exists := false
+		for _, e := range existing {
+			if val == e {
+				exists = true
+				break
+			}
+		}
+		if !exists {
+			newTags = append(newTags, val)
+		}
+	}
+	return newTags
+}
+
 func dedupeFlagActions(flags, existing []string) []string {
 	newFlags := []string{}
 	for _, val := range dedupeStrings(flags) {
···
 	// before creating a report, query to see if automod has already reported this account in the past week for the same reason
 	// NOTE: this is running in an inner loop (if there are multiple reports), which is a bit inefficient, but seems acceptable
 
-	// ModerationQueryEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, inc ludeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string)
 	resp, err := toolsozone.ModerationQueryEvents(
 		ctx,
 		xrpcc,
-		nil,
-		nil,
-		"",
-		"",
-		"",
-		xrpcc.Auth.Did,
-		"",
-		false,
-		false,
-		5,
-		nil,
-		nil,
-		nil,
-		"",
-		did.String(),
-		[]string{"tools.ozone.moderation.defs#modEventReport"},
+		nil,            // addedLabels []string
+		nil,            // addedTags []string
+		nil,            // collections []string
+		"",             // comment string
+		"",             // createdAfter string
+		"",             // createdBefore string
+		xrpcc.Auth.Did, // createdBy string
+		"",             // cursor string
+		false,          // hasComment bool
+		false,          // includeAllUserRecords bool
+		5,              // limit int64
+		nil,            // removedLabels []string
+		nil,            // removedTags []string
+		nil,            // reportTypes []string
+		"",             // sortDirection string
+		did.String(),   // subject string
+		"",             // subjectType string
+		[]string{"tools.ozone.moderation.defs#modEventReport"}, // types []string
 	)
 
 	if err != nil {
···
 	// before creating a report, query to see if automod has already reported this account in the past week for the same reason
 	// NOTE: this is running in an inner loop (if there are multiple reports), which is a bit inefficient, but seems acceptable
 
-	// ModerationQueryEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, inc ludeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string)
 	resp, err := toolsozone.ModerationQueryEvents(
 		ctx,
 		xrpcc,
-		nil,
-		nil,
-		"",
-		"",
-		"",
-		xrpcc.Auth.Did,
-		"",
-		false,
-		false,
-		5,
-		nil,
-		nil,
-		nil,
-		"",
-		uri.String(),
-		[]string{"tools.ozone.moderation.defs#modEventReport"},
+		nil,            // addedLabels []string
+		nil,            // addedTags []string
+		nil,            // collections []string
+		"",             // comment string
+		"",             // createdAfter string
+		"",             // createdBefore string
+		xrpcc.Auth.Did, // createdBy string
+		"",             // cursor string
+		false,          // hasComment bool
+		false,          // includeAllUserRecords bool
+		5,              // limit int64
+		nil,            // removedLabels []string
+		nil,            // removedTags []string
+		nil,            // reportTypes []string
+		"",             // sortDirection string
+		uri.String(),   // subject string
+		"",             // subjectType string
+		[]string{"tools.ozone.moderation.defs#modEventReport"}, // types []string
 	)
 	if err != nil {
 		return false, err

automod/engine/ruleset.go

···
 	RecordRules       []RecordRuleFunc
 	RecordDeleteRules []RecordRuleFunc
 	IdentityRules     []IdentityRuleFunc
+	AccountRules      []AccountRuleFunc
 	BlobRules         []BlobRuleFunc
 	NotificationRules []NotificationRuleFunc
 	OzoneEventRules   []OzoneEventRuleFunc
···
 		err := f(c)
 		if err != nil {
 			c.Logger.Error("identity rule execution failed", "err", err)
+		}
+	}
+	return nil
+}
+
+// Executes rules for account update events.
+func (r *RuleSet) CallAccountRules(c *AccountContext) error {
+	for _, f := range r.AccountRules {
+		err := f(c)
+		if err != nil {
+			c.Logger.Error("account rule execution failed", "err", err)
 		}
 	}
 	return nil

automod/engine/ruletypes.go

···
 )
 
 type IdentityRuleFunc = func(c *AccountContext) error
+type AccountRuleFunc = func(c *AccountContext) error
 type RecordRuleFunc = func(c *RecordContext) error
 type PostRuleFunc = func(c *RecordContext, post *appbsky.FeedPost) error
 type ProfileRuleFunc = func(c *RecordContext, profile *appbsky.ActorProfile) error

automod/engine/util.go

···
 package engine
 
+import (
+	"net/url"
+	"strings"
+)
+
 func dedupeStrings(in []string) []string {
 	var out []string
 	seen := make(map[string]bool)
···
 	}
 	return out
 }
+
+// get the cid from a bluesky cdn url
+func cidFromCdnUrl(str *string) *string {
+	if str == nil {
+		return nil
+	}
+
+	u, err := url.Parse(*str)
+	if err != nil || u.Host != "cdn.bsky.app" {
+		return nil
+	}
+
+	parts := strings.Split(u.Path, "/")
+	if len(parts) != 6 {
+		return nil
+	}
+
+	return &strings.Split(parts[5], "@")[0]
+}

automod/helpers/account.go

···
+package helpers
+
+import (
+	"time"
+
+	"github.com/bluesky-social/indigo/automod"
+)
+
+// no accounts exist before this time
+var atprotoAccountEpoch = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
+
+// returns true if account creation timestamp is plausible: not-nil, not in distant past, not in the future
+func plausibleAccountCreation(when *time.Time) bool {
+	if when == nil {
+		return false
+	}
+	// this is mostly to check for misconfigurations or null values (eg, UNIX epoch zero means "unknown" not actually 1970)
+	if !when.After(atprotoAccountEpoch) {
+		return false
+	}
+	// a timestamp in the future would also indicate some misconfiguration
+	if when.After(time.Now().Add(time.Hour)) {
+		return false
+	}
+	return true
+}
+
+// checks if account was created recently, based on either public or private account metadata. if metadata isn't available at all, or seems bogus, returns 'false'
+func AccountIsYoungerThan(c *automod.AccountContext, age time.Duration) bool {
+	// TODO: consider swapping priority order here (and below)
+	if c.Account.CreatedAt != nil && plausibleAccountCreation(c.Account.CreatedAt) {
+		return time.Since(*c.Account.CreatedAt) < age
+	}
+	if c.Account.Private != nil && plausibleAccountCreation(c.Account.Private.IndexedAt) {
+		return time.Since(*c.Account.Private.IndexedAt) < age
+	}
+	return false
+}
+
+// checks if account was *not* created recently, based on either public or private account metadata. if metadata isn't available at all, or seems bogus, returns 'false'
+func AccountIsOlderThan(c *automod.AccountContext, age time.Duration) bool {
+	if c.Account.CreatedAt != nil && plausibleAccountCreation(c.Account.CreatedAt) {
+		return time.Since(*c.Account.CreatedAt) >= age
+	}
+	if c.Account.Private != nil && plausibleAccountCreation(c.Account.Private.IndexedAt) {
+		return time.Since(*c.Account.Private.IndexedAt) >= age
+	}
+	return false
+}

automod/helpers/account_test.go

···
+package helpers
+
+import (
+	"testing"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/identity"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/bluesky-social/indigo/automod"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestAccountIsYoungerThan(t *testing.T) {
+	assert := assert.New(t)
+
+	am := automod.AccountMeta{
+		Identity: &identity.Identity{
+			DID:    syntax.DID("did:plc:abc111"),
+			Handle: syntax.Handle("handle.example.com"),
+		},
+		Profile: automod.ProfileSummary{},
+		Private: nil,
+	}
+	now := time.Now()
+	ac := automod.AccountContext{
+		Account: am,
+	}
+	assert.False(AccountIsYoungerThan(&ac, time.Hour))
+	assert.False(AccountIsOlderThan(&ac, time.Hour))
+
+	ac.Account.CreatedAt = &now
+	assert.True(AccountIsYoungerThan(&ac, time.Hour))
+	assert.False(AccountIsOlderThan(&ac, time.Hour))
+
+	yesterday := time.Now().Add(-1 * time.Hour * 24)
+	ac.Account.CreatedAt = &yesterday
+	assert.False(AccountIsYoungerThan(&ac, time.Hour))
+	assert.True(AccountIsOlderThan(&ac, time.Hour))
+
+	old := time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)
+	ac.Account.CreatedAt = &old
+	assert.False(AccountIsYoungerThan(&ac, time.Hour))
+	assert.False(AccountIsYoungerThan(&ac, time.Hour*24*365*100))
+	assert.False(AccountIsOlderThan(&ac, time.Hour))
+	assert.False(AccountIsOlderThan(&ac, time.Hour*24*365*100))
+
+	future := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)
+	ac.Account.CreatedAt = &future
+	assert.False(AccountIsYoungerThan(&ac, time.Hour))
+	assert.False(AccountIsOlderThan(&ac, time.Hour))
+
+	ac.Account.CreatedAt = nil
+	ac.Account.Private = &automod.AccountPrivate{
+		Email:     "[e-mail]",
+		IndexedAt: &yesterday,
+	}
+	assert.True(AccountIsYoungerThan(&ac, 48*time.Hour))
+	assert.False(AccountIsYoungerThan(&ac, time.Hour))
+	assert.True(AccountIsOlderThan(&ac, time.Hour))
+	assert.False(AccountIsOlderThan(&ac, 48*time.Hour))
+}

automod/helpers/bsky_test.go

···
+package helpers
+
+import (
+	comatproto "github.com/bluesky-social/indigo/api/atproto"
+	appbsky "github.com/bluesky-social/indigo/api/bsky"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestParentOrRootIsDid(t *testing.T) {
+	assert := assert.New(t)
+
+	post1 := &appbsky.FeedPost{
+		Text: "some random post that i dreamt up last night, idk",
+		Reply: &appbsky.FeedPost_ReplyRef{
+			Root: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:abc123/app.bsky.feed.post/rkey123",
+			},
+			Parent: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:abc123/app.bsky.feed.post/rkey123",
+			},
+		},
+	}
+
+	post2 := &appbsky.FeedPost{
+		Text: "some random post that i dreamt up last night, idk",
+		Reply: &appbsky.FeedPost_ReplyRef{
+			Root: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:321abc/app.bsky.feed.post/rkey123",
+			},
+			Parent: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:abc123/app.bsky.feed.post/rkey123",
+			},
+		},
+	}
+
+	post3 := &appbsky.FeedPost{
+		Text: "some random post that i dreamt up last night, idk",
+		Reply: &appbsky.FeedPost_ReplyRef{
+			Root: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:abc123/app.bsky.feed.post/rkey123",
+			},
+			Parent: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:321abc/app.bsky.feed.post/rkey123",
+			},
+		},
+	}
+
+	post4 := &appbsky.FeedPost{
+		Text: "some random post that i dreamt up last night, idk",
+		Reply: &appbsky.FeedPost_ReplyRef{
+			Root: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:321abc/app.bsky.feed.post/rkey123",
+			},
+			Parent: &comatproto.RepoStrongRef{
+				Uri: "at://did:plc:321abc/app.bsky.feed.post/rkey123",
+			},
+		},
+	}
+
+	assert.True(PostParentOrRootIsDid(post1, "did:plc:abc123"))
+	assert.False(PostParentOrRootIsDid(post1, "did:plc:321abc"))
+
+	assert.True(PostParentOrRootIsDid(post2, "did:plc:abc123"))
+	assert.True(PostParentOrRootIsDid(post2, "did:plc:321abc"))
+
+	assert.True(PostParentOrRootIsDid(post3, "did:plc:abc123"))
+	assert.True(PostParentOrRootIsDid(post3, "did:plc:321abc"))
+
+	assert.False(PostParentOrRootIsDid(post4, "did:plc:abc123"))
+	assert.True(PostParentOrRootIsDid(post4, "did:plc:321abc"))
+
+	didList1 := []string{
+		"did:plc:cba321",
+		"did:web:bsky.app",
+		"did:plc:abc123",
+	}
+
+	didList2 := []string{
+		"did:plc:321cba",
+		"did:web:bsky.app",
+		"did:plc:123abc",
+	}
+
+	assert.True(PostParentOrRootIsAnyDid(post1, didList1))
+	assert.False(PostParentOrRootIsAnyDid(post1, didList2))
+}
+
+func TestPostMentionsDid(t *testing.T) {
+	assert := assert.New(t)
+
+	post := &appbsky.FeedPost{
+		Text: "@hailey.at what is upppp also hello to @darthbluesky.bsky.social",
+		Facets: []*appbsky.RichtextFacet{
+			{
+				Features: []*appbsky.RichtextFacet_Features_Elem{
+					{
+						RichtextFacet_Mention: &appbsky.RichtextFacet_Mention{
+							Did: "did:plc:abc123",
+						},
+					},
+				},
+				Index: &appbsky.RichtextFacet_ByteSlice{
+					ByteStart: 0,
+					ByteEnd:   9,
+				},
+			},
+			{
+				Features: []*appbsky.RichtextFacet_Features_Elem{
+					{
+						RichtextFacet_Mention: &appbsky.RichtextFacet_Mention{
+							Did: "did:plc:abc456",
+						},
+					},
+				},
+				Index: &appbsky.RichtextFacet_ByteSlice{
+					ByteStart: 39,
+					ByteEnd:   63,
+				},
+			},
+		},
+	}
+	assert.True(PostMentionsDid(post, "did:plc:abc123"))
+	assert.False(PostMentionsDid(post, "did:plc:cba321"))
+
+	didList1 := []string{
+		"did:plc:cba321",
+		"did:web:bsky.app",
+		"did:plc:abc456",
+	}
+
+	didList2 := []string{
+		"did:plc:321cba",
+		"did:web:bsky.app",
+		"did:plc:123abc",
+	}
+
+	assert.True(PostMentionsAnyDid(post, didList1))
+	assert.False(PostMentionsAnyDid(post, didList2))
+}

automod/helpers/text.go

···
+package helpers
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/spaolacci/murmur3"
+)
+
+func DedupeStrings(in []string) []string {
+	var out []string
+	seen := make(map[string]bool)
+	for _, v := range in {
+		if !seen[v] {
+			out = append(out, v)
+			seen[v] = true
+		}
+	}
+	return out
+}
+
+// returns a fast, compact hash of a string
+//
+// current implementation uses murmur3, default seed, and hex encoding
+func HashOfString(s string) string {
+	val := murmur3.Sum64([]byte(s))
+	return fmt.Sprintf("%016x", val)
+}
+
+// based on: https://stackoverflow.com/a/48769624, with no trailing period allowed
+var urlRegex = regexp.MustCompile(`(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-&?=%.]*[\w/\-&?=%]+`)
+
+func ExtractTextURLs(raw string) []string {
+	return urlRegex.FindAllString(raw, -1)
+}

automod/helpers/text_test.go

···
+package helpers
+
+import (
+	"testing"
+
+	"github.com/bluesky-social/indigo/automod/keyword"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestTokenizeText(t *testing.T) {
+	assert := assert.New(t)
+
+	fixtures := []struct {
+		s   string
+		out []string
+	}{
+		{
+			s:   "1 'Two' three!",
+			out: []string{"1", "two", "three"},
+		},
+		{
+			s:   "  foo1;bar2,baz3...",
+			out: []string{"foo1", "bar2", "baz3"},
+		},
+		{
+			s:   "https://example.com/index.html",
+			out: []string{"https", "example", "com", "index", "html"},
+		},
+	}
+
+	for _, fix := range fixtures {
+		assert.Equal(fix.out, keyword.TokenizeText(fix.s))
+	}
+}
+
+func TestExtractURL(t *testing.T) {
+	assert := assert.New(t)
+
+	fixtures := []struct {
+		s   string
+		out []string
+	}{
+		{
+			s:   "this is a description with example.com mentioned in the middle",
+			out: []string{"example.com"},
+		},
+		{
+			s:   "this is another example with https://en.wikipedia.org/index.html: and archive.org, and https://eff.org/... and bsky.app.",
+			out: []string{"https://en.wikipedia.org/index.html", "archive.org", "https://eff.org/", "bsky.app"},
+		},
+	}
+
+	for _, fix := range fixtures {
+		assert.Equal(fix.out, ExtractTextURLs(fix.s))
+	}
+}
+
+func TestHashOfString(t *testing.T) {
+	assert := assert.New(t)
+
+	// hashing function should be consistent over time
+	assert.Equal("4e6f69c0e3d10992", HashOfString("dummy-value"))
+}

automod/keyword/tokenize.go

···
 )
 
 var (
-	puncChars     = regexp.MustCompile(`[[:punct:]]+`)
-	nonTokenChars = regexp.MustCompile(`[^\pL\pN\s]+`)
+	puncChars                    = regexp.MustCompile(`[[:punct:]]+`)
+	nonTokenChars                = regexp.MustCompile(`[^\pL\pN\s]+`)
+	nonTokenCharsSkipCensorChars = regexp.MustCompile(`[^\pL\pN\s#*_-]`)
 )
 
 // Splits free-form text in to tokens, including lower-case, unicode normalization, and some unicode folding.
 //
 // The intent is for this to work similarly to an NLP tokenizer, as might be used in a fulltext search engine, and enable fast matching to a list of known tokens. It might eventually even do stemming, removing pluralization (trailing "s" for English), etc.
-func TokenizeText(text string) []string {
+func TokenizeTextWithRegex(text string, nonTokenCharsRegex *regexp.Regexp) []string {
 	// this function needs to be re-defined in every function call to prevent a race condition
 	normFunc := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC)
-	split := strings.ToLower(nonTokenChars.ReplaceAllString(text, " "))
-	bare := strings.ToLower(nonTokenChars.ReplaceAllString(split, ""))
+	split := strings.ToLower(nonTokenCharsRegex.ReplaceAllString(text, " "))
+	bare := strings.ToLower(nonTokenCharsRegex.ReplaceAllString(split, ""))
 	norm, _, err := transform.String(normFunc, bare)
 	if err != nil {
 		slog.Warn("unicode normalization error", "err", err)
 		norm = bare
 	}
 	return strings.Fields(norm)
+}
+
+func TokenizeText(text string) []string {
+	return TokenizeTextWithRegex(text, nonTokenChars)
+}
+
+func TokenizeTextSkippingCensorChars(text string) []string {
+	return TokenizeTextWithRegex(text, nonTokenCharsSkipCensorChars)
 }
 
 func splitIdentRune(c rune) bool {

automod/keyword/tokenize_test.go

···
 package keyword
 
 import (
+	"regexp"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
···
 		{text: "Hello, โลก!", out: []string{"hello", "โลก"}},
 		{text: "Gdańsk", out: []string{"gdansk"}},
 		{text: " foo1;bar2,baz3...", out: []string{"foo1", "bar2", "baz3"}},
+		{text: "foo*bar", out: []string{"foo", "bar"}},
+		{text: "foo-bar", out: []string{"foo", "bar"}},
+		{text: "foo_bar", out: []string{"foo", "bar"}},
 	}
 
 	for _, fix := range fixtures {
 		assert.Equal(fix.out, TokenizeText(fix.text))
+	}
+}
+
+func TestTokenizeTextWithCensorChars(t *testing.T) {
+	assert := assert.New(t)
+
+	fixtures := []struct {
+		text string
+		out  []string
+	}{
+		{text: "", out: []string{}},
+		{text: "Hello, โลก!", out: []string{"hello", "โลก"}},
+		{text: "Gdańsk", out: []string{"gdansk"}},
+		{text: " foo1;bar2,baz3...", out: []string{"foo1", "bar2", "baz3"}},
+		{text: "foo*bar,foo&bar", out: []string{"foo*bar", "foo", "bar"}},
+		{text: "foo-bar,foo&bar", out: []string{"foo-bar", "foo", "bar"}},
+		{text: "foo_bar,foo&bar", out: []string{"foo_bar", "foo", "bar"}},
+		{text: "foo#bar,foo&bar", out: []string{"foo#bar", "foo", "bar"}},
+	}
+
+	for _, fix := range fixtures {
+		assert.Equal(fix.out, TokenizeTextSkippingCensorChars(fix.text))
+	}
+}
+
+func TestTokenizeTextWithCustomRegex(t *testing.T) {
+	assert := assert.New(t)
+
+	fixtures := []struct {
+		text string
+		out  []string
+	}{
+		{text: "", out: []string{}},
+		{text: "Hello, โลก!", out: []string{"hello", "โลก"}},
+		{text: "Gdańsk", out: []string{"gdansk"}},
+		{text: " foo1;bar2,baz3...", out: []string{"foo1", "bar2", "baz3"}},
+		{text: "foo*bar", out: []string{"foo", "bar"}},
+		{text: "foo&bar,foo*bar", out: []string{"foo&bar", "foo", "bar"}},
+	}
+
+	regex := regexp.MustCompile(`[^\pL\pN\s&]`)
+	for _, fix := range fixtures {
+		assert.Equal(fix.out, TokenizeTextWithRegex(fix.text, regex))
 	}
 }
 

automod/pkg.go

···
 )
 
 type Engine = engine.Engine
+type EngineConfig = engine.EngineConfig
 type AccountMeta = engine.AccountMeta
 type ProfileSummary = engine.ProfileSummary
 type AccountPrivate = engine.AccountPrivate

automod/rules/gtube.go

···
 	if strings.Contains(post.Text, gtubeString) {
 		c.AddRecordLabel("spam")
 		c.Notify("slack")
+		c.AddRecordTag("gtube-record")
 	}
 	return nil
 }
···
 	if profile.Description != nil && strings.Contains(*profile.Description, gtubeString) {
 		c.AddRecordLabel("spam")
 		c.Notify("slack")
+		c.AddAccountTag("gtuber-account")
 	}
 	return nil
 }

automod/rules/harassment.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = HarassmentTargetInteractionPostRule
 
 // looks for new accounts, which interact with frequently-harassed accounts, and report them for review
 func HarassmentTargetInteractionPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 24*time.Hour) {
 		return nil
 	}
 
 	var interactionDIDs []string
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		return err
 	}
···
 			interactionDIDs = append(interactionDIDs, *pf.DID)
 		}
 	}
-	if post.Reply != nil && !IsSelfThread(c, post) {
+	if post.Reply != nil && !helpers.IsSelfThread(c, post) {
 		parentURI, err := syntax.ParseATURI(post.Reply.Parent.Uri)
 		if err != nil {
 			return err
···
 		return nil
 	}
 
-	interactionDIDs = dedupeStrings(interactionDIDs)
+	interactionDIDs = helpers.DedupeStrings(interactionDIDs)
 	for _, d := range interactionDIDs {
 		did, err := syntax.ParseDID(d)
 		if err != nil {
···
 
 // looks for new accounts, which frequently post the same type of content
 func HarassmentTrivialPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
 		return nil
 	}
 

automod/rules/hashtags.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	"github.com/bluesky-social/indigo/automod/keyword"
 )
 
 // looks for specific hashtags from known lists
 func BadHashtagsPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	for _, tag := range ExtractHashtagsPost(post) {
-		tag = NormalizeHashtag(tag)
+	for _, tag := range helpers.ExtractHashtagsPost(post) {
+		tag = helpers.NormalizeHashtag(tag)
 		// skip some bad-word hashtags which frequently false-positive
 		if tag == "nazi" || tag == "hitler" {
 			continue
···
 
 // if a post is "almost all" hashtags, it might be a form of search spam
 func TooManyHashtagsPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	tags := ExtractHashtagsPost(post)
+	tags := helpers.ExtractHashtagsPost(post)
 	tagChars := 0
 	for _, tag := range tags {
 		tagChars += len(tag)

automod/rules/helpers.go automod/helpers/bsky.go

···
-package rules
+package helpers
 
 import (
 	"fmt"
-	"regexp"
-	"time"
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/keyword"
-
-	"github.com/spaolacci/murmur3"
 )
 
-func dedupeStrings(in []string) []string {
-	var out []string
-	seen := make(map[string]bool)
-	for _, v := range in {
-		if !seen[v] {
-			out = append(out, v)
-			seen[v] = true
-		}
-	}
-	return out
-}
-
 func ExtractHashtagsPost(post *appbsky.FeedPost) []string {
 	var tags []string
 	for _, tag := range post.Tags {
···
 			}
 		}
 	}
-	return dedupeStrings(tags)
+	return DedupeStrings(tags)
 }
 
 func NormalizeHashtag(raw string) string {
···
 			}
 		}
 	}
-	return dedupeStrings(out)
+	return DedupeStrings(out)
 }
 
 func ExtractBlobCIDsProfile(profile *appbsky.ActorProfile) []string {
···
 	if profile.Banner != nil {
 		out = append(out, profile.Banner.Ref.String())
 	}
-	return dedupeStrings(out)
+	return DedupeStrings(out)
 }
 
 func ExtractTextTokensPost(post *appbsky.FeedPost) []string {
···
 	return keyword.TokenizeText(s)
 }
 
-// based on: https://stackoverflow.com/a/48769624, with no trailing period allowed
-var urlRegex = regexp.MustCompile(`(?:(?:https?|ftp):\/\/)?[\w/\-?=%.]+\.[\w/\-&?=%.]*[\w/\-&?=%]+`)
-
-func ExtractTextURLs(raw string) []string {
-	return urlRegex.FindAllString(raw, -1)
-}
-
 func ExtractTextURLsProfile(profile *appbsky.ActorProfile) []string {
 	s := ""
 	if profile.Description != nil {
···
 		return true
 	}
 	return false
-}
-
-// returns a fast, compact hash of a string
-//
-// current implementation uses murmur3, default seed, and hex encoding
-func HashOfString(s string) string {
-	val := murmur3.Sum64([]byte(s))
-	return fmt.Sprintf("%016x", val)
 }
 
 func ParentOrRootIsFollower(c *automod.RecordContext, post *appbsky.FeedPost) bool {
···
 	return false
 }
 
-// no accounts exist before this time
-var atprotoAccountEpoch = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
-
-// returns true if account creation timestamp is plausible: not-nil, not in distant past, not in the future
-func plausibleAccountCreation(when *time.Time) bool {
-	if when == nil {
+func PostParentOrRootIsDid(post *appbsky.FeedPost, did string) bool {
+	if post.Reply == nil {
 		return false
 	}
-	// this is mostly to check for misconfigurations or null values (eg, UNIX epoch zero means "unknown" not actually 1970)
-	if !when.After(atprotoAccountEpoch) {
+
+	rootUri, err := syntax.ParseATURI(post.Reply.Root.Uri)
+	if err != nil || !rootUri.Authority().IsDID() {
 		return false
 	}
-	// a timestamp in the future would also indicate some misconfiguration
-	if when.After(time.Now().Add(time.Hour)) {
+
+	parentUri, err := syntax.ParseATURI(post.Reply.Parent.Uri)
+	if err != nil || !parentUri.Authority().IsDID() {
 		return false
 	}
-	return true
+
+	return rootUri.Authority().String() == did || parentUri.Authority().String() == did
 }
 
-// checks if account was created recently, based on either public or private account metadata. if metadata isn't available at all, or seems bogus, returns 'false'
-func AccountIsYoungerThan(c *automod.AccountContext, age time.Duration) bool {
-	// TODO: consider swapping priority order here (and below)
-	if c.Account.CreatedAt != nil && plausibleAccountCreation(c.Account.CreatedAt) {
-		return time.Since(*c.Account.CreatedAt) < age
+func PostParentOrRootIsAnyDid(post *appbsky.FeedPost, dids []string) bool {
+	if post.Reply == nil {
+		return false
 	}
-	if c.Account.Private != nil && plausibleAccountCreation(c.Account.Private.IndexedAt) {
-		return time.Since(*c.Account.Private.IndexedAt) < age
+
+	for _, did := range dids {
+		if PostParentOrRootIsDid(post, did) {
+			return true
+		}
 	}
+
 	return false
 }
 
-// checks if account was *not* created recently, based on either public or private account metadata. if metadata isn't available at all, or seems bogus, returns 'false'
-func AccountIsOlderThan(c *automod.AccountContext, age time.Duration) bool {
-	if c.Account.CreatedAt != nil && plausibleAccountCreation(c.Account.CreatedAt) {
-		return time.Since(*c.Account.CreatedAt) >= age
+func PostMentionsDid(post *appbsky.FeedPost, did string) bool {
+	facets, err := ExtractFacets(post)
+	if err != nil {
+		return false
+	}
+
+	for _, facet := range facets {
+		if facet.DID != nil && *facet.DID == did {
+			return true
+		}
 	}
-	if c.Account.Private != nil && plausibleAccountCreation(c.Account.Private.IndexedAt) {
-		return time.Since(*c.Account.Private.IndexedAt) >= age
+
+	return false
+}
+
+func PostMentionsAnyDid(post *appbsky.FeedPost, dids []string) bool {
+	for _, did := range dids {
+		if PostMentionsDid(post, did) {
+			return true
+		}
 	}
+
 	return false
 }

automod/rules/helpers_test.go

···
-package rules
-
-import (
-	"testing"
-	"time"
-
-	"github.com/bluesky-social/indigo/atproto/identity"
-	"github.com/bluesky-social/indigo/atproto/syntax"
-	"github.com/bluesky-social/indigo/automod"
-	"github.com/bluesky-social/indigo/automod/keyword"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestTokenizeText(t *testing.T) {
-	assert := assert.New(t)
-
-	fixtures := []struct {
-		s   string
-		out []string
-	}{
-		{
-			s:   "1 'Two' three!",
-			out: []string{"1", "two", "three"},
-		},
-		{
-			s:   "  foo1;bar2,baz3...",
-			out: []string{"foo1", "bar2", "baz3"},
-		},
-		{
-			s:   "https://example.com/index.html",
-			out: []string{"https", "example", "com", "index", "html"},
-		},
-	}
-
-	for _, fix := range fixtures {
-		assert.Equal(fix.out, keyword.TokenizeText(fix.s))
-	}
-}
-
-func TestExtractURL(t *testing.T) {
-	assert := assert.New(t)
-
-	fixtures := []struct {
-		s   string
-		out []string
-	}{
-		{
-			s:   "this is a description with example.com mentioned in the middle",
-			out: []string{"example.com"},
-		},
-		{
-			s:   "this is another example with https://en.wikipedia.org/index.html: and archive.org, and https://eff.org/... and bsky.app.",
-			out: []string{"https://en.wikipedia.org/index.html", "archive.org", "https://eff.org/", "bsky.app"},
-		},
-	}
-
-	for _, fix := range fixtures {
-		assert.Equal(fix.out, ExtractTextURLs(fix.s))
-	}
-}
-
-func TestHashOfString(t *testing.T) {
-	assert := assert.New(t)
-
-	// hashing function should be consistent over time
-	assert.Equal("4e6f69c0e3d10992", HashOfString("dummy-value"))
-}
-
-func TestAccountIsYoungerThan(t *testing.T) {
-	assert := assert.New(t)
-
-	am := automod.AccountMeta{
-		Identity: &identity.Identity{
-			DID:    syntax.DID("did:plc:abc111"),
-			Handle: syntax.Handle("handle.example.com"),
-		},
-		Profile: automod.ProfileSummary{},
-		Private: nil,
-	}
-	now := time.Now()
-	ac := automod.AccountContext{
-		Account: am,
-	}
-	assert.False(AccountIsYoungerThan(&ac, time.Hour))
-	assert.False(AccountIsOlderThan(&ac, time.Hour))
-
-	ac.Account.CreatedAt = &now
-	assert.True(AccountIsYoungerThan(&ac, time.Hour))
-	assert.False(AccountIsOlderThan(&ac, time.Hour))
-
-	yesterday := time.Now().Add(-1 * time.Hour * 24)
-	ac.Account.CreatedAt = &yesterday
-	assert.False(AccountIsYoungerThan(&ac, time.Hour))
-	assert.True(AccountIsOlderThan(&ac, time.Hour))
-
-	old := time.Date(1990, 1, 1, 0, 0, 0, 0, time.UTC)
-	ac.Account.CreatedAt = &old
-	assert.False(AccountIsYoungerThan(&ac, time.Hour))
-	assert.False(AccountIsYoungerThan(&ac, time.Hour*24*365*100))
-	assert.False(AccountIsOlderThan(&ac, time.Hour))
-	assert.False(AccountIsOlderThan(&ac, time.Hour*24*365*100))
-
-	future := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)
-	ac.Account.CreatedAt = &future
-	assert.False(AccountIsYoungerThan(&ac, time.Hour))
-	assert.False(AccountIsOlderThan(&ac, time.Hour))
-
-	ac.Account.CreatedAt = nil
-	ac.Account.Private = &automod.AccountPrivate{
-		Email:     "[e-mail]",
-		IndexedAt: &yesterday,
-	}
-	assert.True(AccountIsYoungerThan(&ac, 48*time.Hour))
-	assert.False(AccountIsYoungerThan(&ac, time.Hour))
-	assert.True(AccountIsOlderThan(&ac, time.Hour))
-	assert.False(AccountIsOlderThan(&ac, 48*time.Hour))
-}

automod/rules/identity.go

···
 
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 // triggers on first identity event for an account (DID)
 func NewAccountRule(c *automod.AccountContext) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(c, 4*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(c, 4*time.Hour) {
 		return nil
 	}
 

automod/rules/keyword.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	"github.com/bluesky-social/indigo/automod/keyword"
 )
 
···
 			isJapanese = true
 		}
 	}
-	for _, tok := range ExtractTextTokensPost(post) {
+	for _, tok := range helpers.ExtractTextTokensPost(post) {
 		word := keyword.SlugIsExplicitSlur(tok)
 		// used very frequently in a reclaimed context
 		if word != "" && word != "faggot" && word != "tranny" && word != "coon" && !(word == "kike" && isJapanese) {
···
 			//c.Notify("slack")
 		}
 	}
-	for _, tok := range ExtractTextTokensProfile(profile) {
+	for _, tok := range helpers.ExtractTextTokensProfile(profile) {
 		// de-pluralize
 		tok = strings.TrimSuffix(tok, "s")
 		if c.InSet("worst-words", tok) {
···
 
 // looks for the specific harassment situation of a replay to another user with only a single word
 func ReplySingleBadWordPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply != nil && !IsSelfThread(c, post) {
-		tokens := ExtractTextTokensPost(post)
+	if post.Reply != nil && !helpers.IsSelfThread(c, post) {
+		tokens := helpers.ExtractTextTokensPost(post)
 		if len(tokens) != 1 {
 			return nil
 		}

automod/rules/mentions.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = DistinctMentionsRule
···
 var _ automod.PostRuleFunc = YoungAccountDistinctMentionsRule
 
 func YoungAccountDistinctMentionsRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 14*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 

automod/rules/misleading.go

···
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
-func isMisleadingURLFacet(facet PostFacet, logger *slog.Logger) bool {
+func isMisleadingURLFacet(facet helpers.PostFacet, logger *slog.Logger) bool {
 	linkURL, err := url.Parse(*facet.URL)
 	if err != nil {
 		logger.Warn("invalid link metadata URL", "url", facet.URL)
···
 	if c.Account.Identity.Handle == "nowbreezing.ntw.app" {
 		return nil
 	}
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		c.Logger.Warn("invalid facets", "err", err)
 		// TODO: or some other "this record is corrupt" indicator?
···
 var _ automod.PostRuleFunc = MisleadingMentionPostRule
 
 func MisleadingMentionPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	facets, err := ExtractFacets(post)
+	facets, err := helpers.ExtractFacets(post)
 	if err != nil {
 		c.Logger.Warn("invalid facets", "err", err)
 		// TODO: or some other "this record is corrupt" indicator?

automod/rules/misleading_test.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/engine"
+	"github.com/bluesky-social/indigo/automod/helpers"
 
 	"github.com/stretchr/testify/assert"
 )
···
 	logger := slog.Default()
 
 	fixtures := []struct {
-		facet PostFacet
+		facet helpers.PostFacet
 		out   bool
 	}{
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://evil.com"),
 			},
 			out: true,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://www.atproto.com",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "https://atproto.com",
 				URL:  pstr("https://www.atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "[example.com]",
 				URL:  pstr("https://www.example.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "example.com...",
 				URL:  pstr("https://example.com.evil.com"),
 			},
 			out: true,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "ATPROTO.com...",
 				URL:  pstr("https://atproto.com"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "1234.5678",
 				URL:  pstr("https://arxiv.org/abs/1234.5678"),
 			},
 			out: false,
 		},
 		{
-			facet: PostFacet{
+			facet: helpers.PostFacet{
 				Text: "www.techdirt.com…",
 				URL:  pstr("https://www.techdirt.com/"),
 			},

automod/rules/nostr.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = NostrSpamPostRule
 
 // looks for new accounts, which frequently post the same type of content
 func NostrSpamPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
 		return nil
 	}
 

automod/rules/promo.go

···
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = AggressivePromotionRule
···
 //
 // this rule depends on ReplyCountPostRule() to set counts
 func AggressivePromotionRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 7*24*time.Hour) {
 		return nil
 	}
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
-	allURLs := ExtractTextURLs(post.Text)
+	allURLs := helpers.ExtractTextURLs(post.Text)
 	if c.Account.Profile.Description != nil {
-		profileURLs := ExtractTextURLs(*c.Account.Profile.Description)
+		profileURLs := helpers.ExtractTextURLs(*c.Account.Profile.Description)
 		allURLs = append(allURLs, profileURLs...)
 	}
 	hasPromo := false

automod/rules/quick.go

···
 
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/automod"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var botLinkStrings = []string{"ainna13762491", "LINK押して", "→ https://tiny", "⇒ http://tiny"}
···
 var _ automod.IdentityRuleFunc = NewAccountBotEmailRule
 
 func NewAccountBotEmailRule(c *automod.AccountContext) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(c, 1*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(c, 1*time.Hour) {
 		return nil
 	}
 
···
 
 // looks for new accounts, which frequently post the same type of content
 func TrivialSpamPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 8*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 8*24*time.Hour) {
 		return nil
 	}
 

automod/rules/replies.go

···
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var _ automod.PostRuleFunc = ReplyCountPostRule
 
 // does not count "self-replies" (direct to self, or in own post thread)
 func ReplyCountPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 //
 // There can be legitimate situations that trigger this rule, so in most situations should be a "report" not "label" action.
 func IdenticalReplyPostRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 	if utf8.RuneCountInString(post.Text) <= 10 {
 		return nil
 	}
-	if AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
+	if helpers.AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 
 	// don't count if there is a follow-back relationship
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 
 	// increment before read. use a specific period (IncrementPeriod()) to reduce the number of counters (one per unique post text)
 	period := countstore.PeriodDay
-	bucket := c.Account.Identity.DID.String() + "/" + HashOfString(post.Text)
+	bucket := c.Account.Identity.DID.String() + "/" + helpers.HashOfString(post.Text)
 	c.IncrementPeriod("reply-text", bucket, period)
 
 	count := c.GetCount("reply-text", bucket, period)
···
 var _ automod.PostRuleFunc = IdenticalReplyPostSameParentRule
 
 func IdenticalReplyPostSameParentRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 
 	postCount := c.Account.PostsCount
-	if AccountIsOlderThan(&c.AccountContext, identicalReplySameParentMaxAge) || postCount >= identicalReplySameParentMaxPosts {
+	if helpers.AccountIsOlderThan(&c.AccountContext, identicalReplySameParentMaxAge) || postCount >= identicalReplySameParentMaxPosts {
 		return nil
 	}
 
 	period := countstore.PeriodHour
-	bucket := c.Account.Identity.DID.String() + "/" + post.Reply.Parent.Uri + "/" + HashOfString(post.Text)
+	bucket := c.Account.Identity.DID.String() + "/" + post.Reply.Parent.Uri + "/" + helpers.HashOfString(post.Text)
 	c.IncrementPeriod("reply-text-same-post", bucket, period)
 
 	count := c.GetCount("reply-text-same-post", bucket, period)
···
 
 func YoungAccountDistinctRepliesRule(c *automod.RecordContext, post *appbsky.FeedPost) error {
 	// only replies, and skip self-replies (eg, threads)
-	if post.Reply == nil || IsSelfThread(c, post) {
+	if post.Reply == nil || helpers.IsSelfThread(c, post) {
 		return nil
 	}
 
···
 	if utf8.RuneCountInString(post.Text) <= 10 {
 		return nil
 	}
-	if AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
+	if helpers.AccountIsOlderThan(&c.AccountContext, 14*24*time.Hour) {
 		return nil
 	}
 
 	// don't count if there is a follow-back relationship
-	if ParentOrRootIsFollower(c, post) {
+	if helpers.ParentOrRootIsFollower(c, post) {
 		return nil
 	}
 

automod/rules/reposts.go

···
 
 	"github.com/bluesky-social/indigo/automod"
 	"github.com/bluesky-social/indigo/automod/countstore"
+	"github.com/bluesky-social/indigo/automod/helpers"
 )
 
 var dailyRepostThresholdWithoutPost = 30
···
 // looks for accounts which do frequent reposts
 func TooManyRepostRule(c *automod.RecordContext) error {
 	// Don't bother checking reposts from accounts older than 30 days
-	if c.Account.Identity == nil || !AccountIsYoungerThan(&c.AccountContext, 30*24*time.Hour) {
+	if c.Account.Identity == nil || !helpers.AccountIsYoungerThan(&c.AccountContext, 30*24*time.Hour) {
 		return nil
 	}
 

automod/visual/hiveai_rule.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/automod"
-	"github.com/bluesky-social/indigo/automod/rules"
+	"github.com/bluesky-social/indigo/automod/helpers"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 )
 
···
 
 	for _, l := range labels {
 		// NOTE: experimenting with profile reporting for new accounts
-		if l == "sexual" && c.RecordOp.Collection.String() == "app.bsky.actor.profile" && rules.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
+		if l == "sexual" && c.RecordOp.Collection.String() == "app.bsky.actor.profile" && helpers.AccountIsYoungerThan(&c.AccountContext, 2*24*time.Hour) {
 			c.ReportRecord(automod.ReportReasonSexual, "possible sexual profile (not labeled yet)")
 			c.Logger.Info("skipping record label", "label", l, "reason", "sexual-profile-experiment")
 		} else {

bgs/bgs.go

···
 }
 
 type BGSConfig struct {
-	SSL               bool
-	CompactInterval   time.Duration
-	DefaultRepoLimit  int64
-	ConcurrencyPerPDS int64
-	MaxQueuePerPDS    int64
+	SSL                  bool
+	CompactInterval      time.Duration
+	DefaultRepoLimit     int64
+	ConcurrencyPerPDS    int64
+	MaxQueuePerPDS       int64
+	NumCompactionWorkers int
 }
 
 func DefaultBGSConfig() *BGSConfig {
 	return &BGSConfig{
-		SSL:               true,
-		CompactInterval:   4 * time.Hour,
-		DefaultRepoLimit:  100,
-		ConcurrencyPerPDS: 100,
-		MaxQueuePerPDS:    1_000,
+		SSL:                  true,
+		CompactInterval:      4 * time.Hour,
+		DefaultRepoLimit:     100,
+		ConcurrencyPerPDS:    100,
+		MaxQueuePerPDS:       1_000,
+		NumCompactionWorkers: 2,
 	}
 }
 
···
 		return nil, err
 	}
 
-	compactor := NewCompactor(nil)
+	cOpts := DefaultCompactorOptions()
+	cOpts.NumWorkers = config.NumCompactionWorkers
+	compactor := NewCompactor(cOpts)
 	compactor.requeueInterval = config.CompactInterval
 	compactor.Start(bgs)
 	bgs.compactor = compactor
···
 	e.GET("/xrpc/com.atproto.sync.notifyOfUpdate", bgs.HandleComAtprotoSyncNotifyOfUpdate)
 	e.GET("/xrpc/_health", bgs.HandleHealthCheck)
 	e.GET("/_health", bgs.HandleHealthCheck)
+	e.GET("/", bgs.HandleHomeMessage)
 
 	admin := e.Group("/admin", bgs.checkAdminAuth)
 
···
 	} else {
 		return c.JSON(200, HealthStatus{Status: "ok"})
 	}
+}
+
+var homeMessage string = `
+d8888b. d888888b  d888b  .d8888. db   dD db    db
+88  '8D   '88'   88' Y8b 88'  YP 88 ,8P' '8b  d8'
+88oooY'    88    88      '8bo.   88,8P    '8bd8'
+88~~~b.    88    88  ooo   'Y8b. 88'8b      88
+88   8D   .88.   88. ~8~ db   8D 88 '88.    88
+Y8888P' Y888888P  Y888P  '8888Y' YP   YD    YP
+
+This is an atproto [https://atproto.com] relay instance, running the 'bigsky' codebase [https://github.com/bluesky-social/indigo]
+
+The firehose WebSocket path is at:  /xrpc/com.atproto.sync.subscribeRepos
+`
+
+func (bgs *BGS) HandleHomeMessage(c echo.Context) error {
+	return c.String(http.StatusOK, homeMessage)
 }
 
 type AuthToken struct {

cmd/beemo/notify_reports.go

···
 		xrpcc.Auth.RefreshJwt = refresh.RefreshJwt
 
 		// query just new reports (regardless of resolution state)
-		// ModerationQueryEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*ModerationQueryEvents_Output, error)
 		var limit int64 = 50
 		me, err := toolsozone.ModerationQueryEvents(
 			cctx.Context,
 			xrpcc,
-			nil,
-			nil,
-			"",
-			"",
-			"",
-			"",
-			"",
-			false,
-			true,
-			limit,
-			nil,
-			nil,
-			nil,
-			"",
-			"",
-			[]string{"tools.ozone.moderation.defs#modEventReport"},
+			nil,   // addedLabels []string
+			nil,   // addedTags []string
+			nil,   // collections []string
+			"",    // comment string
+			"",    // createdAfter string
+			"",    // createdBefore string
+			"",    // createdBy string
+			"",    // cursor string
+			false, // hasComment bool
+			true,  // includeAllUserRecords bool
+			limit, // limit int64
+			nil,   // removedLabels []string
+			nil,   // removedTags []string
+			nil,   // reportTypes []string
+			"",    // sortDirection string
+			"",    // subject string
+			"",    // subjectType string
+			[]string{"tools.ozone.moderation.defs#modEventReport"}, // types []string
 		)
 		if err != nil {
 			return err

cmd/bigsky/main.go

···
 			Name:    "data-dir",
 			Usage:   "path of directory for CAR files and other data",
 			Value:   "data/bigsky",
-			EnvVars: []string{"DATA_DIR"},
+			EnvVars: []string{"RELAY_DATA_DIR", "DATA_DIR"},
 		},
 		&cli.StringFlag{
 			Name:    "plc-host",
···
 			EnvVars: []string{"RELAY_METRICS_LISTEN", "BGS_METRICS_LISTEN"},
 		},
 		&cli.StringFlag{
-			Name:  "disk-persister-dir",
-			Usage: "set directory for disk persister (implicitly enables disk persister)",
+			Name:    "disk-persister-dir",
+			Usage:   "set directory for disk persister (implicitly enables disk persister)",
+			EnvVars: []string{"RELAY_PERSISTER_DIR"},
 		},
 		&cli.StringFlag{
 			Name:    "admin-key",
···
 			EnvVars: []string{"RELAY_DID_CACHE_SIZE"},
 			Value:   5_000_000,
 		},
+		&cli.DurationFlag{
+			Name:    "event-playback-ttl",
+			Usage:   "time to live for event playback buffering (only applies to disk persister)",
+			EnvVars: []string{"RELAY_EVENT_PLAYBACK_TTL"},
+			Value:   72 * time.Hour,
+		},
+		&cli.IntFlag{
+			Name:    "num-compaction-workers",
+			EnvVars: []string{"RELAY_NUM_COMPACTION_WORKERS"},
+			Value:   2,
+		},
 	}
 
 	app.Action = runBigsky
···
 
 	if dpd := cctx.String("disk-persister-dir"); dpd != "" {
 		log.Infow("setting up disk persister")
-		dp, err := events.NewDiskPersistence(dpd, "", db, events.DefaultDiskPersistOptions())
+
+		pOpts := events.DefaultDiskPersistOptions()
+		pOpts.Retention = cctx.Duration("event-playback-ttl")
+		dp, err := events.NewDiskPersistence(dpd, "", db, pOpts)
 		if err != nil {
 			return fmt.Errorf("setting up disk persister: %w", err)
 		}
···
 	bgsConfig.ConcurrencyPerPDS = cctx.Int64("concurrency-per-pds")
 	bgsConfig.MaxQueuePerPDS = cctx.Int64("max-queue-per-pds")
 	bgsConfig.DefaultRepoLimit = cctx.Int64("default-repo-limit")
+	bgsConfig.NumCompactionWorkers = cctx.Int("num-compaction-workers")
 	bgs, err := libbgs.NewBGS(db, ix, repoman, evtman, cachedidr, rf, hr, bgsConfig)
 	if err != nil {
 		return err

cmd/goat/account_migrate.go

···
 	"time"
 
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
-	appbsky "github.com/bluesky-social/indigo/api/bsky"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/xrpc"
 
···
 
 	slog.Info("migrating preferences")
 	// TODO: service proxy header for AppView?
-	prefResp, err := appbsky.ActorGetPreferences(ctx, oldClient)
+	prefResp, err := ActorGetPreferences(ctx, oldClient)
 	if err != nil {
 		return fmt.Errorf("failed fetching old preferences: %w", err)
 	}
-	err = appbsky.ActorPutPreferences(ctx, &newClient, &appbsky.ActorPutPreferences_Input{
+	err = ActorPutPreferences(ctx, &newClient, &ActorPutPreferences_Input{
 		Preferences: prefResp.Preferences,
 	})
 	if err != nil {

cmd/goat/actorgetPreferences.go

···
+// Copied from indigo:api/atproto/actorgetPreferences.go
+
+package main
+
+// schema: app.bsky.actor.getPreferences
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// ActorGetPreferences_Output is the output of a app.bsky.actor.getPreferences call.
+type ActorGetPreferences_Output struct {
+	Preferences []map[string]any `json:"preferences" cborgen:"preferences"`
+}
+
+// ActorGetPreferences calls the XRPC method "app.bsky.actor.getPreferences".
+func ActorGetPreferences(ctx context.Context, c *xrpc.Client) (*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 {
+		return nil, err
+	}
+
+	return &out, nil
+}

cmd/goat/actorputPreferences.go

···
+// Copied from indigo:api/atproto/actorputPreferences.go
+
+package main
+
+// schema: app.bsky.actor.putPreferences
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// ActorPutPreferences_Input is the input argument to a app.bsky.actor.putPreferences call.
+type ActorPutPreferences_Input struct {
+	Preferences []map[string]any `json:"preferences" cborgen:"preferences"`
+}
+
+// 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 {
+		return err
+	}
+
+	return nil
+}

cmd/goat/bsky_prefs.go

···
 	"fmt"
 	"os"
 
-	appbsky "github.com/bluesky-social/indigo/api/bsky"
-
 	"github.com/urfave/cli/v2"
 )
 
···
 	}
 
 	// TODO: does indigo API code crash with unsupported preference '$type'? Eg "Lexicon decoder" with unsupported type.
-	resp, err := appbsky.ActorGetPreferences(ctx, xrpcc)
+	resp, err := ActorGetPreferences(ctx, xrpcc)
 	if err != nil {
 		return fmt.Errorf("failed fetching old preferences: %w", err)
 	}
···
 		return err
 	}
 
-	var prefsArray []appbsky.ActorDefs_Preferences_Elem
-	err = json.Unmarshal(prefsBytes, &prefsArray)
-	if err != nil {
+	var prefsArray []map[string]any
+	if err = json.Unmarshal(prefsBytes, &prefsArray); err != nil {
 		return err
 	}
 
-	// WARNING: might clobber off-Lexicon or new-Lexicon data fields (which don't round-trip deserialization)
-	err = appbsky.ActorPutPreferences(ctx, xrpcc, &appbsky.ActorPutPreferences_Input{
+	err = ActorPutPreferences(ctx, xrpcc, &ActorPutPreferences_Input{
 		Preferences: prefsArray,
 	})
 	if err != nil {

cmd/goat/record.go

···
 	"github.com/bluesky-social/indigo/atproto/data"
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"github.com/bluesky-social/indigo/xrpc"
 
 	"github.com/urfave/cli/v2"
···
 		return err
 	}
 
-	// TODO: replace this with something that allows arbitrary Lexicons, instead of needing registered types
-	var recordVal lexutil.LexiconTypeDecoder
-	if err = recordVal.UnmarshalJSON(recordBytes); err != nil {
+	recordVal, err := data.UnmarshalJSON(recordBytes)
+	if err != nil {
 		return err
 	}
 
···
 	}
 	validate := !cctx.Bool("no-validate")
 
-	resp, err := comatproto.RepoCreateRecord(ctx, xrpcc, &comatproto.RepoCreateRecord_Input{
+	resp, err := RepoCreateRecord(ctx, xrpcc, &RepoCreateRecord_Input{
 		Collection: nsid,
 		Repo:       xrpcc.Auth.Did,
-		Record:     &recordVal,
+		Record:     recordVal,
 		Rkey:       rkey,
 		Validate:   &validate,
 	})
···
 		return err
 	}
 
-	// TODO: replace this with something that allows arbitrary Lexicons, instead of needing registered types
-	var recordVal lexutil.LexiconTypeDecoder
-	if err = recordVal.UnmarshalJSON(recordBytes); err != nil {
+	recordVal, err := data.UnmarshalJSON(recordBytes)
+	if err != nil {
 		return err
 	}
 
 	validate := !cctx.Bool("no-validate")
 
-	resp, err := comatproto.RepoPutRecord(ctx, xrpcc, &comatproto.RepoPutRecord_Input{
+	resp, err := RepoPutRecord(ctx, xrpcc, &RepoPutRecord_Input{
 		Collection: nsid,
 		Repo:       xrpcc.Auth.Did,
-		Record:     &recordVal,
+		Record:     recordVal,
 		Rkey:       rkey,
 		Validate:   &validate,
 		SwapRecord: existing.Cid,

cmd/goat/repocreateRecord.go

···
+// Copied from indigo:api/atproto/repocreateRecords.go
+
+package main
+
+// schema: com.atproto.repo.createRecord
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// RepoDefs_CommitMeta is a "commitMeta" in the com.atproto.repo.defs schema.
+type RepoDefs_CommitMeta struct {
+	Cid string `json:"cid" cborgen:"cid"`
+	Rev string `json:"rev" cborgen:"rev"`
+}
+
+// RepoCreateRecord_Input is the input argument to a com.atproto.repo.createRecord call.
+type RepoCreateRecord_Input struct {
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record itself. Must contain a $type field.
+	Record map[string]any `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The Record Key.
+	Rkey *string `json:"rkey,omitempty" cborgen:"rkey,omitempty"`
+	// swapCommit: Compare and swap with the previous commit by CID.
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// validate: Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
+	Validate *bool `json:"validate,omitempty" cborgen:"validate,omitempty"`
+}
+
+// RepoCreateRecord_Output is the output of a com.atproto.repo.createRecord call.
+type RepoCreateRecord_Output struct {
+	Cid              string               `json:"cid" cborgen:"cid"`
+	Commit           *RepoDefs_CommitMeta `json:"commit,omitempty" cborgen:"commit,omitempty"`
+	Uri              string               `json:"uri" cborgen:"uri"`
+	ValidationStatus *string              `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoCreateRecord calls the XRPC method "com.atproto.repo.createRecord".
+func RepoCreateRecord(ctx context.Context, c *xrpc.Client, 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 {
+		return nil, err
+	}
+
+	return &out, nil
+}

cmd/goat/repoputRecord.go

···
+// Copied from indigo:api/atproto/repoputRecords.go
+
+package main
+
+// schema: com.atproto.repo.putRecord
+
+import (
+	"context"
+
+	"github.com/bluesky-social/indigo/xrpc"
+)
+
+// RepoPutRecord_Input is the input argument to a com.atproto.repo.putRecord call.
+type RepoPutRecord_Input struct {
+	// collection: The NSID of the record collection.
+	Collection string `json:"collection" cborgen:"collection"`
+	// record: The record to write.
+	Record map[string]any `json:"record" cborgen:"record"`
+	// repo: The handle or DID of the repo (aka, current account).
+	Repo string `json:"repo" cborgen:"repo"`
+	// rkey: The Record Key.
+	Rkey string `json:"rkey" cborgen:"rkey"`
+	// swapCommit: Compare and swap with the previous commit by CID.
+	SwapCommit *string `json:"swapCommit,omitempty" cborgen:"swapCommit,omitempty"`
+	// swapRecord: Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation
+	SwapRecord *string `json:"swapRecord" cborgen:"swapRecord"`
+	// validate: Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.
+	Validate *bool `json:"validate,omitempty" cborgen:"validate,omitempty"`
+}
+
+// RepoPutRecord_Output is the output of a com.atproto.repo.putRecord call.
+type RepoPutRecord_Output struct {
+	Cid              string               `json:"cid" cborgen:"cid"`
+	Commit           *RepoDefs_CommitMeta `json:"commit,omitempty" cborgen:"commit,omitempty"`
+	Uri              string               `json:"uri" cborgen:"uri"`
+	ValidationStatus *string              `json:"validationStatus,omitempty" cborgen:"validationStatus,omitempty"`
+}
+
+// RepoPutRecord calls the XRPC method "com.atproto.repo.putRecord".
+func RepoPutRecord(ctx context.Context, c *xrpc.Client, 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 {
+		return nil, err
+	}
+
+	return &out, nil
+}

cmd/gosky/admin.go

···
 		xrpcc.AdminToken = &adminKey
 
 		// fetch recent moderation reports
-		// AdminQueryModerationEvents(ctx context.Context, c *xrpc.Client, createdBy string, cursor string, includeAllUserRecords bool, limit int64, sortDirection string, subject string, types []string) (*AdminQueryModerationEvents_Output, error)
 		resp, err := toolsozone.ModerationQueryEvents(
 			ctx,
 			xrpcc,
-			nil,
-			nil,
-			"",
-			"",
-			"",
-			"",
-			"",
-			false,
-			false,
-			100,
-			nil,
-			nil,
-			nil,
-			"",
-			"",
-			[]string{"tools.ozone.moderation.defs#modEventReport"},
+			nil,   // addedLabels []string
+			nil,   // addedTags []string
+			nil,   // collections []string
+			"",    // comment string
+			"",    // createdAfter string
+			"",    // createdBefore string
+			"",    // createdBy string
+			"",    // cursor string
+			false, // hasComment bool
+			false, // includeAllUserRecords bool
+			100,   // limit int64
+			nil,   // removedLabels []string
+			nil,   // removedTags []string
+			nil,   // reportTypes []string
+			"",    // sortDirection string
+			"",    // subject string
+			"",    // subjectType string
+			[]string{"tools.ozone.moderation.defs#modEventReport"}, // types []string
 		)
 		if err != nil {
 			return err
···
 		resp, err := toolsozone.ModerationQueryEvents(
 			ctx,
 			xrpcc,
-			nil,
-			nil,
-			"",
-			"",
-			"",
-			"",
-			"",
-			false,
-			false,
-			100,
-			nil,
-			nil,
-			nil,
-			"",
-			"",
-			[]string{"tools.ozone.moderation.defs#modEventReport"},
+			nil,   // addedLabels []string
+			nil,   // addedTags []string
+			nil,   // collections []string
+			"",    // comment string
+			"",    // createdAfter string
+			"",    // createdBefore string
+			"",    // createdBy string
+			"",    // cursor string
+			false, // hasComment bool
+			false, // includeAllUserRecords bool
+			100,   // limit int64
+			nil,   // removedLabels []string
+			nil,   // removedTags []string
+			nil,   // reportTypes []string
+			"",    // sortDirection string
+			"",    // subject string
+			"",    // subjectType string
+			[]string{"tools.ozone.moderation.defs#modEventReport"}, // types []string
 		)
 		if err != nil {
 			return err

cmd/hepa/consumer.go

···
-package main
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync/atomic"
-
-	comatproto "github.com/bluesky-social/indigo/api/atproto"
-	"github.com/bluesky-social/indigo/atproto/syntax"
-	"github.com/bluesky-social/indigo/automod"
-	"github.com/bluesky-social/indigo/events/schedulers/autoscaling"
-	"github.com/bluesky-social/indigo/events/schedulers/parallel"
-	lexutil "github.com/bluesky-social/indigo/lex/util"
-
-	"github.com/bluesky-social/indigo/events"
-	"github.com/bluesky-social/indigo/repo"
-	"github.com/bluesky-social/indigo/repomgr"
-	"github.com/carlmjohnson/versioninfo"
-	"github.com/gorilla/websocket"
-)
-
-func (s *Server) RunConsumer(ctx context.Context) error {
-
-	cur, err := s.ReadLastCursor(ctx)
-	if err != nil {
-		return err
-	}
-
-	dialer := websocket.DefaultDialer
-	u, err := url.Parse(s.relayHost)
-	if err != nil {
-		return fmt.Errorf("invalid relayHost URI: %w", err)
-	}
-	u.Path = "xrpc/com.atproto.sync.subscribeRepos"
-	if cur != 0 {
-		u.RawQuery = fmt.Sprintf("cursor=%d", cur)
-	}
-	s.logger.Info("subscribing to repo event stream", "upstream", s.relayHost, "cursor", cur)
-	con, _, err := dialer.Dial(u.String(), http.Header{
-		"User-Agent": []string{fmt.Sprintf("hepa/%s", versioninfo.Short())},
-	})
-	if err != nil {
-		return fmt.Errorf("subscribing to firehose failed (dialing): %w", err)
-	}
-
-	rsc := &events.RepoStreamCallbacks{
-		RepoCommit: func(evt *comatproto.SyncSubscribeRepos_Commit) error {
-			atomic.StoreInt64(&s.lastSeq, evt.Seq)
-			return s.HandleRepoCommit(ctx, evt)
-		},
-		RepoIdentity: func(evt *comatproto.SyncSubscribeRepos_Identity) error {
-			atomic.StoreInt64(&s.lastSeq, evt.Seq)
-			did, err := syntax.ParseDID(evt.Did)
-			if err != nil {
-				s.logger.Error("bad DID in RepoIdentity event", "did", evt.Did, "seq", evt.Seq, "err", err)
-				return nil
-			}
-			if err := s.engine.ProcessIdentityEvent(ctx, "identity", did); err != nil {
-				s.logger.Error("processing repo identity failed", "did", evt.Did, "seq", evt.Seq, "err", err)
-			}
-			return nil
-		},
-		RepoAccount: func(evt *comatproto.SyncSubscribeRepos_Account) error {
-			atomic.StoreInt64(&s.lastSeq, evt.Seq)
-			did, err := syntax.ParseDID(evt.Did)
-			if err != nil {
-				s.logger.Error("bad DID in RepoAccount event", "did", evt.Did, "seq", evt.Seq, "err", err)
-				return nil
-			}
-			if err := s.engine.ProcessIdentityEvent(ctx, "account", did); err != nil {
-				s.logger.Error("processing repo account failed", "did", evt.Did, "seq", evt.Seq, "err", err)
-			}
-			return nil
-		},
-		// TODO: deprecated
-		RepoHandle: func(evt *comatproto.SyncSubscribeRepos_Handle) error {
-			atomic.StoreInt64(&s.lastSeq, evt.Seq)
-			did, err := syntax.ParseDID(evt.Did)
-			if err != nil {
-				s.logger.Error("bad DID in RepoHandle event", "did", evt.Did, "handle", evt.Handle, "seq", evt.Seq, "err", err)
-				return nil
-			}
-			if err := s.engine.ProcessIdentityEvent(ctx, "handle", did); err != nil {
-				s.logger.Error("processing handle update failed", "did", evt.Did, "handle", evt.Handle, "seq", evt.Seq, "err", err)
-			}
-			return nil
-		},
-		// TODO: deprecated
-		RepoTombstone: func(evt *comatproto.SyncSubscribeRepos_Tombstone) error {
-			atomic.StoreInt64(&s.lastSeq, evt.Seq)
-			did, err := syntax.ParseDID(evt.Did)
-			if err != nil {
-				s.logger.Error("bad DID in RepoTombstone event", "did", evt.Did, "seq", evt.Seq, "err", err)
-				return nil
-			}
-			if err := s.engine.ProcessIdentityEvent(ctx, "tombstone", did); err != nil {
-				s.logger.Error("processing repo tombstone failed", "did", evt.Did, "seq", evt.Seq, "err", err)
-			}
-			return nil
-		},
-	}
-
-	var scheduler events.Scheduler
-	if s.firehoseParallelism > 0 {
-		// use a fixed-parallelism scheduler if configured
-		scheduler = parallel.NewScheduler(
-			s.firehoseParallelism,
-			1000,
-			s.relayHost,
-			rsc.EventHandler,
-		)
-		s.logger.Info("hepa scheduler configured", "scheduler", "parallel", "initial", s.firehoseParallelism)
-	} else {
-		// otherwise use auto-scaling scheduler
-		scaleSettings := autoscaling.DefaultAutoscaleSettings()
-		// start at higher parallelism (somewhat arbitrary)
-		scaleSettings.Concurrency = 4
-		scaleSettings.MaxConcurrency = 200
-		scheduler = autoscaling.NewScheduler(scaleSettings, s.relayHost, rsc.EventHandler)
-		s.logger.Info("hepa scheduler configured", "scheduler", "autoscaling", "initial", scaleSettings.Concurrency, "max", scaleSettings.MaxConcurrency)
-	}
-
-	return events.HandleRepoStream(ctx, con, scheduler)
-}
-
-// TODO: move this to a "ParsePath" helper in syntax package?
-func splitRepoPath(path string) (syntax.NSID, syntax.RecordKey, error) {
-	parts := strings.SplitN(path, "/", 3)
-	if len(parts) != 2 {
-		return "", "", fmt.Errorf("invalid record path: %s", path)
-	}
-	collection, err := syntax.ParseNSID(parts[0])
-	if err != nil {
-		return "", "", err
-	}
-	rkey, err := syntax.ParseRecordKey(parts[1])
-	if err != nil {
-		return "", "", err
-	}
-	return collection, rkey, nil
-}
-
-// NOTE: for now, this function basically never errors, just logs and returns nil. Should think through error processing better.
-func (s *Server) HandleRepoCommit(ctx context.Context, evt *comatproto.SyncSubscribeRepos_Commit) error {
-
-	logger := s.logger.With("event", "commit", "did", evt.Repo, "rev", evt.Rev, "seq", evt.Seq)
-	logger.Debug("received commit event")
-
-	if evt.TooBig {
-		logger.Warn("skipping tooBig events for now")
-		return nil
-	}
-
-	did, err := syntax.ParseDID(evt.Repo)
-	if err != nil {
-		logger.Error("bad DID syntax in event", "err", err)
-		return nil
-	}
-
-	rr, err := repo.ReadRepoFromCar(ctx, bytes.NewReader(evt.Blocks))
-	if err != nil {
-		logger.Error("failed to read repo from car", "err", err)
-		return nil
-	}
-
-	// empty commit is a special case, temporarily, basically indicates "new account"
-	if len(evt.Ops) == 0 {
-		if err := s.engine.ProcessIdentityEvent(ctx, "create", did); err != nil {
-			s.logger.Error("processing handle update failed", "did", evt.Repo, "rev", evt.Rev, "seq", evt.Seq, "err", err)
-		}
-	}
-
-	for _, op := range evt.Ops {
-		logger = logger.With("eventKind", op.Action, "path", op.Path)
-		collection, rkey, err := splitRepoPath(op.Path)
-		if err != nil {
-			logger.Error("invalid path in repo op")
-			return nil
-		}
-
-		ek := repomgr.EventKind(op.Action)
-		switch ek {
-		case repomgr.EvtKindCreateRecord, repomgr.EvtKindUpdateRecord:
-			// read the record bytes from blocks, and verify CID
-			rc, recCBOR, err := rr.GetRecordBytes(ctx, op.Path)
-			if err != nil {
-				logger.Error("reading record from event blocks (CAR)", "err", err)
-				break
-			}
-			if op.Cid == nil || lexutil.LexLink(rc) != *op.Cid {
-				logger.Error("mismatch between commit op CID and record block", "recordCID", rc, "opCID", op.Cid)
-				break
-			}
-			var action string
-			switch ek {
-			case repomgr.EvtKindCreateRecord:
-				action = automod.CreateOp
-			case repomgr.EvtKindUpdateRecord:
-				action = automod.UpdateOp
-			default:
-				logger.Error("impossible event kind", "kind", ek)
-				break
-			}
-			recCID := syntax.CID(op.Cid.String())
-			err = s.engine.ProcessRecordOp(ctx, automod.RecordOp{
-				Action:     action,
-				DID:        did,
-				Collection: collection,
-				RecordKey:  rkey,
-				CID:        &recCID,
-				RecordCBOR: *recCBOR,
-			})
-			if err != nil {
-				logger.Error("engine failed to process record", "err", err)
-				continue
-			}
-		case repomgr.EvtKindDeleteRecord:
-			err = s.engine.ProcessRecordOp(ctx, automod.RecordOp{
-				Action:     automod.DeleteOp,
-				DID:        did,
-				Collection: collection,
-				RecordKey:  rkey,
-				CID:        nil,
-				RecordCBOR: nil,
-			})
-			if err != nil {
-				logger.Error("engine failed to process record", "err", err)
-				continue
-			}
-		default:
-			// TODO: should this be an error?
-		}
-	}
-
-	return nil
-}

cmd/hepa/consumer_ozone.go

···
-package main
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	toolsozone "github.com/bluesky-social/indigo/api/ozone"
-	"github.com/bluesky-social/indigo/atproto/syntax"
-)
-
-func (s *Server) RunOzoneConsumer(ctx context.Context) error {
-
-	cur, err := s.ReadLastOzoneCursor(ctx)
-	if err != nil {
-		return err
-	}
-
-	if cur == "" {
-		cur = syntax.DatetimeNow().String()
-	}
-	since, err := syntax.ParseDatetime(cur)
-	if err != nil {
-		return err
-	}
-
-	s.logger.Info("subscribing to ozone event log", "upstream", s.engine.OzoneClient.Host, "cursor", cur, "since", since)
-	var limit int64 = 50
-	period := time.Second * 5
-
-	for {
-		//func ModerationQueryEvents(ctx context.Context, c *xrpc.Client, addedLabels []string, addedTags []string, comment string, createdAfter string, createdBefore string, createdBy string, cursor string, hasComment bool, includeAllUserRecords bool, limit int64, removedLabels []string, removedTags []string, reportTypes []string, sortDirection string, subject string, types []string) (*ModerationQueryEvents_Output, error) {
-		me, err := toolsozone.ModerationQueryEvents(
-			ctx,
-			s.engine.OzoneClient,
-			nil,            // addedLabels: If specified, only events where all of these labels were added are returned
-			nil,            // addedTags: If specified, only events where all of these tags were added are returned
-			"",             // comment: If specified, only events with comments containing the keyword are returned
-			since.String(), // createdAfter: Retrieve events created after a given timestamp
-			"",             // createdBefore: Retrieve events created before a given timestamp
-			"",             // createdBy
-			"",             // cursor
-			false,          // hasComment: If true, only events with comments are returned
-			true,           // includeAllUserRecords: If true, events on all record types (posts, lists, profile etc.) owned by the did are returned
-			limit,
-			nil,   // removedLabels: If specified, only events where all of these labels were removed are returned
-			nil,   // removedTags
-			nil,   // reportTypes
-			"asc", // sortDirection: Sort direction for the events. Defaults to descending order of created at timestamp.
-			"",    // subject
-			nil,   // types: The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned.
-		)
-		if err != nil {
-			s.logger.Warn("ozone query events failed; sleeping then will retrying", "err", err, "period", period.String())
-			time.Sleep(period)
-			continue
-		}
-
-		// track if the response contained anything new
-		anyNewEvents := false
-		for _, evt := range me.Events {
-			createdAt, err := syntax.ParseDatetime(evt.CreatedAt)
-			if err != nil {
-				return fmt.Errorf("invalid time format for ozone 'createdAt': %w", err)
-			}
-			// skip if the timestamp is the exact same
-			if createdAt == since {
-				continue
-			}
-			anyNewEvents = true
-			// TODO: is there a race condition here?
-			if !createdAt.Time().After(since.Time()) {
-				s.logger.Error("out of order ozone event", "createdAt", createdAt, "since", since)
-				return fmt.Errorf("out of order ozone event")
-			}
-			if err = s.HandleOzoneEvent(ctx, evt); err != nil {
-				s.logger.Error("failed to process ozone event", "event", evt)
-			}
-			since = createdAt
-			s.lastOzoneCursor.Store(since.String())
-		}
-		if !anyNewEvents {
-			s.logger.Debug("... ozone poller sleeping", "period", period.String())
-			time.Sleep(period)
-		}
-	}
-}
-
-func (s *Server) HandleOzoneEvent(ctx context.Context, eventView *toolsozone.ModerationDefs_ModEventView) error {
-
-	s.logger.Debug("received ozone event", "eventID", eventView.Id, "createdAt", eventView.CreatedAt)
-
-	if err := s.engine.ProcessOzoneEvent(ctx, eventView); err != nil {
-		s.logger.Error("engine failed to process ozone event", "err", err)
-	}
-	return nil
-}

cmd/hepa/main.go

···
 	"github.com/bluesky-social/indigo/atproto/identity/redisdir"
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/bluesky-social/indigo/automod/capture"
+	"github.com/bluesky-social/indigo/automod/consumer"
 
 	"github.com/carlmjohnson/versioninfo"
 	_ "github.com/joho/godotenv/autoload"
···
 			dir,
 			Config{
 				Logger:              logger,
-				RelayHost:           cctx.String("atp-relay-host"),
+				RelayHost:           cctx.String("atp-relay-host"), // DEPRECATED
 				BskyHost:            cctx.String("atp-bsky-host"),
 				OzoneHost:           cctx.String("atp-ozone-host"),
 				OzoneDID:            cctx.String("ozone-did"),
···
 				AbyssPassword:       cctx.String("abyss-password"),
 				RatelimitBypass:     cctx.String("ratelimit-bypass"),
 				RulesetName:         cctx.String("ruleset"),
-				FirehoseParallelism: cctx.Int("firehose-parallelism"),
+				FirehoseParallelism: cctx.Int("firehose-parallelism"), // DEPRECATED
 				PreScreenHost:       cctx.String("prescreen-host"),
 				PreScreenToken:      cctx.String("prescreen-token"),
 			},
···
 			return fmt.Errorf("failed to construct server: %v", err)
 		}
 
+		// ozone event consumer (if configured)
+		if srv.Engine.OzoneClient != nil {
+			oc := consumer.OzoneConsumer{
+				Logger:      logger.With("subsystem", "ozone-consumer"),
+				RedisClient: srv.RedisClient,
+				OzoneClient: srv.Engine.OzoneClient,
+				Engine:      srv.Engine,
+			}
+
+			go func() {
+				if err := oc.Run(ctx); err != nil {
+					slog.Error("ozone consumer failed", "err", err)
+				}
+			}()
+
+			go func() {
+				if err := oc.RunPersistCursor(ctx); err != nil {
+					slog.Error("ozone cursor routine failed", "err", err)
+				}
+			}()
+		}
+
 		// prometheus HTTP endpoint: /metrics
 		go func() {
 			runtime.SetBlockProfileRate(10)
···
 			}
 		}()
 
-		go func() {
-			if err := srv.RunPersistCursor(ctx); err != nil {
-				slog.Error("cursor routine failed", "err", err)
+		// firehose event consumer (note this is actually mandatory)
+		relayHost := cctx.String("atp-relay-host")
+		if relayHost != "" {
+			fc := consumer.FirehoseConsumer{
+				Engine:      srv.Engine,
+				Logger:      logger.With("subsystem", "firehose-consumer"),
+				Host:        cctx.String("atp-relay-host"),
+				Parallelism: cctx.Int("firehose-parallelism"),
+				RedisClient: srv.RedisClient,
 			}
-		}()
 
-		// ozone event consumer (if configured)
-		if srv.engine.OzoneClient != nil {
 			go func() {
-				if err := srv.RunOzoneConsumer(ctx); err != nil {
-					slog.Error("ozone consumer failed", "err", err)
+				if err := fc.RunPersistCursor(ctx); err != nil {
+					slog.Error("cursor routine failed", "err", err)
 				}
 			}()
 
-			go func() {
-				if err := srv.RunPersistOzoneCursor(ctx); err != nil {
-					slog.Error("ozone cursor routine failed", "err", err)
-				}
-			}()
+			if err := fc.Run(ctx); err != nil {
+				return fmt.Errorf("failure consuming and processing firehose: %w", err)
+			}
 		}
 
-		// firehose event consumer (main processor)
-		if err := srv.RunConsumer(ctx); err != nil {
-			return fmt.Errorf("failure consuming and processing firehose: %w", err)
-		}
 		return nil
 	},
 }
···
 			return err
 		}
 
-		return capture.FetchAndProcessRecord(ctx, srv.engine, aturi)
+		return capture.FetchAndProcessRecord(ctx, srv.Engine, aturi)
 	},
 }
 
···
 			return err
 		}
 
-		return capture.FetchAndProcessRecent(ctx, srv.engine, *atid, cctx.Int("limit"))
+		return capture.FetchAndProcessRecent(ctx, srv.Engine, *atid, cctx.Int("limit"))
 	},
 }
 
···
 			return err
 		}
 
-		cap, err := capture.CaptureRecent(ctx, srv.engine, *atid, cctx.Int("limit"))
+		cap, err := capture.CaptureRecent(ctx, srv.Engine, *atid, cctx.Int("limit"))
 		if err != nil {
 			return err
 		}

cmd/hepa/server.go

···
 	"net/http"
 	"os"
 	"strings"
-	"sync/atomic"
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/identity"
···
 )
 
 type Server struct {
-	relayHost           string
-	firehoseParallelism int
+	Engine      *automod.Engine
+	RedisClient *redis.Client
+
+	relayHost           string // DEPRECATED
+	firehoseParallelism int    // DEPRECATED
 	logger              *slog.Logger
-	engine              *automod.Engine
-	rdb                 *redis.Client
-
-	// lastSeq is the most recent event sequence number we've received and begun to handle.
-	// This number is periodically persisted to redis, if redis is present.
-	// The value is best-effort (the stream handling itself is concurrent, so event numbers may not be monotonic),
-	// but nonetheless, you must use atomics when updating or reading this (to avoid data races).
-	lastSeq int64
-
-	// same as lastSeq, but for Ozone timestamp cursor. the value is a string.
-	lastOzoneCursor atomic.Value
 }
 
 type Config struct {
 	Logger              *slog.Logger
-	RelayHost           string
+	RelayHost           string // DEPRECATED
 	BskyHost            string
 	OzoneHost           string
 	OzoneDID            string
···
 	AbyssPassword       string
 	RulesetName         string
 	RatelimitBypass     string
-	FirehoseParallelism int
+	FirehoseParallelism int // DEPRECATED
 	PreScreenHost       string
 	PreScreenToken      string
 }
···
 		relayHost:           config.RelayHost,
 		firehoseParallelism: config.FirehoseParallelism,
 		logger:              logger,
-		engine:              &engine,
-		rdb:                 rdb,
+		Engine:              &engine,
+		RedisClient:         rdb,
 	}
 
 	return s, nil
···
 	http.Handle("/metrics", promhttp.Handler())
 	return http.ListenAndServe(listen, nil)
 }
-
-var cursorKey = "hepa/seq"
-var ozoneCursorKey = "hepa/ozoneTimestamp"
-
-func (s *Server) ReadLastCursor(ctx context.Context) (int64, error) {
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		s.logger.Info("redis not configured, skipping cursor read")
-		return 0, nil
-	}
-
-	val, err := s.rdb.Get(ctx, cursorKey).Int64()
-	if err == redis.Nil {
-		s.logger.Info("no pre-existing cursor in redis")
-		return 0, nil
-	} else if err != nil {
-		return 0, err
-	}
-	s.logger.Info("successfully found prior subscription cursor seq in redis", "seq", val)
-	return val, nil
-}
-
-func (s *Server) ReadLastOzoneCursor(ctx context.Context) (string, error) {
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		s.logger.Info("redis not configured, skipping ozone cursor read")
-		return "", nil
-	}
-
-	val, err := s.rdb.Get(ctx, ozoneCursorKey).Result()
-	if err == redis.Nil || val == "" {
-		s.logger.Info("no pre-existing ozone cursor in redis")
-		return "", nil
-	} else if err != nil {
-		return "", err
-	}
-	s.logger.Info("successfully found prior ozone offset timestamp in redis", "cursor", val)
-	return val, nil
-}
-
-func (s *Server) PersistCursor(ctx context.Context) error {
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		return nil
-	}
-	lastSeq := atomic.LoadInt64(&s.lastSeq)
-	if lastSeq <= 0 {
-		return nil
-	}
-	err := s.rdb.Set(ctx, cursorKey, lastSeq, 14*24*time.Hour).Err()
-	return err
-}
-
-func (s *Server) PersistOzoneCursor(ctx context.Context) error {
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		return nil
-	}
-	lastCursor := s.lastOzoneCursor.Load()
-	if lastCursor == nil || lastCursor == "" {
-		return nil
-	}
-	err := s.rdb.Set(ctx, ozoneCursorKey, lastCursor, 14*24*time.Hour).Err()
-	return err
-}
-
-// this method runs in a loop, persisting the current cursor state every 5 seconds
-func (s *Server) RunPersistCursor(ctx context.Context) error {
-
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		return nil
-	}
-	ticker := time.NewTicker(5 * time.Second)
-	for {
-		select {
-		case <-ctx.Done():
-			lastSeq := atomic.LoadInt64(&s.lastSeq)
-			if lastSeq >= 1 {
-				s.logger.Info("persisting final cursor seq value", "seq", lastSeq)
-				err := s.PersistCursor(ctx)
-				if err != nil {
-					s.logger.Error("failed to persist cursor", "err", err, "seq", lastSeq)
-				}
-			}
-			return nil
-		case <-ticker.C:
-			lastSeq := atomic.LoadInt64(&s.lastSeq)
-			if lastSeq >= 1 {
-				err := s.PersistCursor(ctx)
-				if err != nil {
-					s.logger.Error("failed to persist cursor", "err", err, "seq", lastSeq)
-				}
-			}
-		}
-	}
-}
-
-// this method runs in a loop, persisting the current cursor state every 5 seconds
-func (s *Server) RunPersistOzoneCursor(ctx context.Context) error {
-
-	// if redis isn't configured, just skip
-	if s.rdb == nil {
-		return nil
-	}
-	ticker := time.NewTicker(5 * time.Second)
-	for {
-		select {
-		case <-ctx.Done():
-			lastCursor := s.lastOzoneCursor.Load()
-			if lastCursor != nil && lastCursor != "" {
-				s.logger.Info("persisting final ozone cursor timestamp", "cursor", lastCursor)
-				err := s.PersistOzoneCursor(ctx)
-				if err != nil {
-					s.logger.Error("failed to persist ozone cursor", "err", err, "cursor", lastCursor)
-				}
-			}
-			return nil
-		case <-ticker.C:
-			lastCursor := s.lastOzoneCursor.Load()
-			if lastCursor != nil && lastCursor != "" {
-				err := s.PersistOzoneCursor(ctx)
-				if err != nil {
-					s.logger.Error("failed to persist ozone cursor", "err", err, "cursor", lastCursor)
-				}
-			}
-		}
-	}
-}

did/web.go

···
 	"fmt"
 	"net/http"
 	"strings"
+	"time"
 	"unicode"
 
 	"github.com/whyrusleeping/go-did"
 	"go.opentelemetry.io/otel"
 )
+
+var webDidDefaultTimeout = 5 * time.Second
 
 type WebResolver struct {
 	Insecure bool
 	// TODO: cache? maybe at a different layer
+
+	client http.Client
 }
 
 func (wr *WebResolver) GetDocument(ctx context.Context, didstr string) (*Document, error) {
+	if wr.client.Timeout == 0 {
+		wr.client.Timeout = webDidDefaultTimeout
+	}
 	ctx, span := otel.Tracer("did").Start(ctx, "didWebGetDocument")
 	defer span.End()
 
···
 		proto = "http"
 	}
 
-	resp, err := http.Get(proto + "://" + val + "/.well-known/did.json")
+	resp, err := wr.client.Get(proto + "://" + val + "/.well-known/did.json")
 	if err != nil {
 		return nil, err
 	}

events/cbor_gen.go

···
 		return fmt.Errorf("EventHeader: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 2)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.MsgType (string) (string)
 		case "t":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("ErrorFrame: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Error (string) (string)
 		case "error":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

events/diskpersist.go

···
 func DefaultDiskPersistOptions() *DiskPersistOptions {
 	return &DiskPersistOptions{
 		EventsPerFile:   10_000,
-		UIDCacheSize:    100_000,
-		DIDCacheSize:    100_000,
+		UIDCacheSize:    1_000_000,
+		DIDCacheSize:    1_000_000,
 		WriteBufferSize: 50,
 		Retention:       time.Hour * 24 * 3, // 3 days
 	}

go.mod

···
 	github.com/flosch/pongo2/v6 v6.0.0
 	github.com/go-redis/cache/v9 v9.0.0
 	github.com/goccy/go-json v0.10.2
+	github.com/gocql/gocql v1.7.0
 	github.com/golang-jwt/jwt v3.2.2+incompatible
 	github.com/gorilla/websocket v1.5.1
 	github.com/hashicorp/go-retryablehttp v0.7.5
···
 	github.com/samber/slog-echo v1.8.0
 	github.com/stretchr/testify v1.9.0
 	github.com/urfave/cli/v2 v2.25.7
-	github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c
+	github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e
 	github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6
 	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1
···
 require (
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/go-redis/redis v6.15.9+incompatible // indirect
+	github.com/golang/snappy v0.0.3 // indirect
+	github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed // indirect
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/klauspost/compress v1.17.3 // indirect
···
 	github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 // indirect
 	go.uber.org/zap v1.26.0 // indirect
 	golang.org/x/exp v0.0.0-20231110203233-9a3e6036ecaa // indirect
+	gopkg.in/inf.v0 v0.9.1 // indirect
 )
 
 require (

go.sum

···
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932 h1:mXoPYz/Ul5HYEDvkta6I8/rnYM5gSdSV2tJ6XbZuEtY=
+github.com/bitly/go-hostpool v0.0.0-20171023180738-a3a6125de932/go.mod h1:NOuUCSz6Q9T7+igc/hlvDOUdtWKryOrtFyIVABv/p7k=
+github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869 h1:DDGfHa7BWjL4YnC6+E63dPcxHo2sUxDIu8g3QgEJdRY=
+github.com/bmizerany/assert v0.0.0-20160611221934-b7ed37b82869/go.mod h1:Ekp36dRnpXw/yCqJaO+ZrUyxD+3VXMFFr56k5XYrpB4=
 github.com/brianvoe/gofakeit/v6 v6.25.0 h1:ZpFjktOpLZUeF8q223o0rUuXtA+m5qW5srjvVi+JkXk=
 github.com/brianvoe/gofakeit/v6 v6.25.0/go.mod h1:Xj58BMSnFqcn/fAQeSK+/PLtC5kSb7FJIq4JyGa8vEs=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
···
 github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0=
 github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
 github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/gocql/gocql v1.7.0 h1:O+7U7/1gSN7QTEAaMEsJc1Oq2QHXvCWoF3DFK9HDHus=
+github.com/gocql/gocql v1.7.0/go.mod h1:vnlvXyFZeLBF0Wy+RS8hrOdbn0UWsWtdg07XJnFxZ+4=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
···
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
 github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
+github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA=
+github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
···
 github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1 h1:6UKoz5ujsI55KNpsJH3UwCq3T8kKbZwNZBNPuTTje8U=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.18.1/go.mod h1:YvJ2f6MplWDhfxiUC3KpyTy76kYUZA4W3pTv/wdKQ9Y=
+github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
+github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed/go.mod h1:tMWxXQ9wFIaZeTI9F+hmhFiGpFmhOHzyShyFUhRm0H4=
 github.com/hashicorp/go-cleanhttp v0.5.2 h1:035FKYIWjmULyFRBKPs8TBQoi0x6d9G4xc9neXJWAZQ=
 github.com/hashicorp/go-cleanhttp v0.5.2/go.mod h1:kO/YDlP8L1346E6Sodw+PrpBSV4/SoxCXGY6BqNFT48=
 github.com/hashicorp/go-hclog v0.9.2 h1:CG6TE5H9/JXsFWJCfoIVpKFIkFe6ysEuHirp4DxCsHI=
···
 github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11 h1:5HZfQkwe0mIfyDmc1Em5GqlNRzcdtlv4HTNmdpt7XH0=
 github.com/whyrusleeping/cbor v0.0.0-20171005072247-63513f603b11/go.mod h1:Wlo/SzPmxVp6vXpGt/zaXhHH0fn4IxgqZc82aKg6bpQ=
-github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c h1:UsxJNcLPfyLyVaA4iusIrsLAqJn/xh36Qgb8emqtXzk=
-github.com/whyrusleeping/cbor-gen v0.1.3-0.20240904181319-8dc02b38228c/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=
+github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4=
+github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=
 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f h1:jQa4QT2UP9WYv2nzyawpKMOCl+Z/jW7djv2/J50lj9E=
 github.com/whyrusleeping/chunker v0.0.0-20181014151217-fe64bd25879f/go.mod h1:p9UJB6dDgdPgMJZs7UjUOdulKyRr9fqkS+6JKAInPy8=
 github.com/whyrusleeping/go-did v0.0.0-20230824162731-404d1707d5d6 h1:yJ9/LwIGIk/c0CdoavpC9RNSGSruIspSZtxG3Nnldic=
···
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
 gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/inf.v0 v0.9.1 h1:73M5CoZyi3ZLMOyDlQh031Cx6N9NDJ2Vvfl76EDAgDc=
+gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
 gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

lex/gen.go

···
 	case "record":
 		return nil
 	case "query":
-		return ts.WriteRPC(w, typename)
+		return ts.WriteRPC(w, typename, fmt.Sprintf("%s_Input", typename))
 	case "procedure":
-		return ts.WriteRPC(w, typename)
+		if ts.Input == nil || ts.Input.Schema == nil || ts.Input.Schema.Type == "object" {
+			return ts.WriteRPC(w, typename, fmt.Sprintf("%s_Input", typename))
+		} else if ts.Input.Schema.Type == "ref" {
+			inputname, _ := ts.namesFromRef(ts.Input.Schema.Ref)
+			return ts.WriteRPC(w, typename, inputname)
+		} else {
+			return fmt.Errorf("unhandled input type: %s", ts.Input.Schema.Type)
+		}
 	case "object", "string":
 		return nil
 	case "subscription":

lex/type_schema.go

···
 	Maximum any `json:"maximum"`
 }
 
-func (s *TypeSchema) WriteRPC(w io.Writer, typename string) error {
+func (s *TypeSchema) WriteRPC(w io.Writer, typename, inputname string) error {
 	pf := printerf(w)
 	fname := typename
 
···
 		case EncodingCBOR, EncodingCAR, EncodingANY, EncodingMP4:
 			params = fmt.Sprintf("%s, input io.Reader", params)
 		case EncodingJSON:
-			params = fmt.Sprintf("%s, input *%s_Input", params, fname)
+			params = fmt.Sprintf("%s, input *%s", params, inputname)
 
 		default:
 			return fmt.Errorf("unsupported input encoding (RPC input): %q", s.Input.Encoding)

lex/util/cbor_gen.go

···
 		return fmt.Errorf("CborChecker: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 5)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Type (string) (string)
 		case "$type":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("LegacyBlob: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (string) (string)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("BlobSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 8)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Ref (util.LexLink) (struct)
 		case "ref":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

lex/util/cbor_gen_test.go

···
 		return fmt.Errorf("basicSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Bool (bool) (bool)
 		case "bool":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("basicSchemaInner: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 6)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Arr ([]string) (slice)
 		case "arr":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("ipldSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.A (util.LexLink) (struct)
 		case "a":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("basicOldSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.A (string) (string)
 		case "a":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("basicOldSchemaInner: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.H (string) (string)
 		case "h":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("ipldOldSchema: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 8192)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 8192)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.A (util.LexLink) (struct)
 		case "a":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

mst/cbor_gen.go

···
 		return fmt.Errorf("nodeData: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Entries ([]mst.treeEntry) (slice)
 		case "e":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("treeEntry: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 1)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.KeySuffix ([]uint8) (slice)
 		case "k":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

repo/cbor_gen.go

···
 		return fmt.Errorf("SignedCommit: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 
···
 		return fmt.Errorf("UnsignedCommit: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 7)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Did (string) (string)
 		case "did":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}
 

util/labels/cbor_gen.go

···
 		return fmt.Errorf("UnsignedLabel: map struct too large (%d)", extra)
 	}
 
-	var name string
 	n := extra
 
+	nameBuf := make([]byte, 3)
 	for i := uint64(0); i < n; i++ {
+		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
+		if err != nil {
+			return err
+		}
 
-		{
-			sval, err := cbg.ReadStringWithMax(cr, 1000000)
-			if err != nil {
+		if !ok {
+			// Field doesn't exist on this type, so ignore it
+			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
 				return err
 			}
-
-			name = string(sval)
+			continue
 		}
 
-		switch name {
+		switch string(nameBuf[:nameLen]) {
 		// t.Cid (string) (string)
 		case "cid":
 
···
 
 		default:
 			// Field doesn't exist on this type, so ignore it
-			cbg.ScanForLinks(r, func(cid.Cid) {})
+			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
+				return err
+			}
 		}
 	}