incremental implementation of xrpc methods

api/atproto/accountcreate.go

···
 }
 
 type AccountCreate_Output struct {
+	Handle     string `json:"handle" cborgen:"handle"`
+	Did        string `json:"did" cborgen:"did"`
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`
 	RefreshJwt string `json:"refreshJwt" cborgen:"refreshJwt"`
-	Handle     string `json:"handle" cborgen:"handle"`
-	Did        string `json:"did" cborgen:"did"`
 }
 
 func AccountCreate(ctx context.Context, c *xrpc.Client, input AccountCreate_Input) (*AccountCreate_Output, error) {

api/atproto/repobatchWrite.go

···
 func init() {
 }
 
-type RepoBatchWrite_Create struct {
-	Action     string  `json:"action" cborgen:"action"`
-	Collection string  `json:"collection" cborgen:"collection"`
-	Rkey       *string `json:"rkey" cborgen:"rkey"`
-	Value      any     `json:"value" cborgen:"value"`
-}
-
-type RepoBatchWrite_Update struct {
-	Action     string `json:"action" cborgen:"action"`
-	Collection string `json:"collection" cborgen:"collection"`
-	Rkey       string `json:"rkey" cborgen:"rkey"`
-	Value      any    `json:"value" cborgen:"value"`
-}
-
-type RepoBatchWrite_Delete struct {
-	Action     string `json:"action" cborgen:"action"`
-	Collection string `json:"collection" cborgen:"collection"`
-	Rkey       string `json:"rkey" cborgen:"rkey"`
-}
-
 type RepoBatchWrite_Input struct {
+	Did      string                              `json:"did" cborgen:"did"`
 	Validate *bool                               `json:"validate" cborgen:"validate"`
 	Writes   []*RepoBatchWrite_Input_Writes_Elem `json:"writes" cborgen:"writes"`
-	Did      string                              `json:"did" cborgen:"did"`
 }
 
 type RepoBatchWrite_Input_Writes_Elem struct {
···
 	default:
 		return fmt.Errorf("closed enums must have a matching value")
 	}
+}
+
+type RepoBatchWrite_Create struct {
+	Action     string  `json:"action" cborgen:"action"`
+	Collection string  `json:"collection" cborgen:"collection"`
+	Rkey       *string `json:"rkey" cborgen:"rkey"`
+	Value      any     `json:"value" cborgen:"value"`
+}
+
+type RepoBatchWrite_Update struct {
+	Value      any    `json:"value" cborgen:"value"`
+	Action     string `json:"action" cborgen:"action"`
+	Collection string `json:"collection" cborgen:"collection"`
+	Rkey       string `json:"rkey" cborgen:"rkey"`
+}
+
+type RepoBatchWrite_Delete struct {
+	Action     string `json:"action" cborgen:"action"`
+	Collection string `json:"collection" cborgen:"collection"`
+	Rkey       string `json:"rkey" cborgen:"rkey"`
 }
 
 func RepoBatchWrite(ctx context.Context, c *xrpc.Client, input RepoBatchWrite_Input) error {

api/atproto/repocreateRecord.go

···
 }
 
 type RepoCreateRecord_Input struct {
-	Validate   *bool  `json:"validate" cborgen:"validate"`
-	Record     any    `json:"record" cborgen:"record"`
 	Did        string `json:"did" cborgen:"did"`
 	Collection string `json:"collection" cborgen:"collection"`
+	Validate   *bool  `json:"validate" cborgen:"validate"`
+	Record     any    `json:"record" cborgen:"record"`
 }
 
 type RepoCreateRecord_Output struct {
-	Uri string `json:"uri" cborgen:"uri"`
 	Cid string `json:"cid" cborgen:"cid"`
+	Uri string `json:"uri" cborgen:"uri"`
 }
 
 func RepoCreateRecord(ctx context.Context, c *xrpc.Client, input RepoCreateRecord_Input) (*RepoCreateRecord_Output, error) {

api/atproto/repodescribe.go

···
 }
 
 type RepoDescribe_Output struct {
+	Handle          string   `json:"handle" cborgen:"handle"`
+	Did             string   `json:"did" cborgen:"did"`
 	DidDoc          any      `json:"didDoc" cborgen:"didDoc"`
 	Collections     []string `json:"collections" cborgen:"collections"`
 	HandleIsCorrect bool     `json:"handleIsCorrect" cborgen:"handleIsCorrect"`
-	Handle          string   `json:"handle" cborgen:"handle"`
-	Did             string   `json:"did" cborgen:"did"`
 }
 
 func RepoDescribe(ctx context.Context, c *xrpc.Client, user string) (*RepoDescribe_Output, error) {

api/atproto/repogetRecord.go

···
 }
 
 type RepoGetRecord_Output struct {
+	Value any     `json:"value" cborgen:"value"`
 	Uri   string  `json:"uri" cborgen:"uri"`
 	Cid   *string `json:"cid" cborgen:"cid"`
-	Value any     `json:"value" cborgen:"value"`
 }
 
 func RepoGetRecord(ctx context.Context, c *xrpc.Client, cid string, collection string, rkey string, user string) (*RepoGetRecord_Output, error) {

api/atproto/sessioncreate.go

···
 }
 
 type SessionCreate_Output struct {
-	Did        string `json:"did" cborgen:"did"`
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`
 	RefreshJwt string `json:"refreshJwt" cborgen:"refreshJwt"`
 	Handle     string `json:"handle" cborgen:"handle"`
+	Did        string `json:"did" cborgen:"did"`
 }
 
 func SessionCreate(ctx context.Context, c *xrpc.Client, input SessionCreate_Input) (*SessionCreate_Output, error) {

api/atproto/sessionrefresh.go

···
 }
 
 type SessionRefresh_Output struct {
+	Did        string `json:"did" cborgen:"did"`
 	AccessJwt  string `json:"accessJwt" cborgen:"accessJwt"`
 	RefreshJwt string `json:"refreshJwt" cborgen:"refreshJwt"`
 	Handle     string `json:"handle" cborgen:"handle"`
-	Did        string `json:"did" cborgen:"did"`
 }
 
 func SessionRefresh(ctx context.Context, c *xrpc.Client) (*SessionRefresh_Output, error) {

api/bsky/actorgetProfile.go

···
 }
 
 type ActorGetProfile_Output struct {
+	Handle         string                   `json:"handle" cborgen:"handle"`
+	Creator        string                   `json:"creator" cborgen:"creator"`
+	DisplayName    *string                  `json:"displayName" cborgen:"displayName"`
 	Description    *string                  `json:"description" cborgen:"description"`
 	FollowersCount int64                    `json:"followersCount" cborgen:"followersCount"`
 	MembersCount   int64                    `json:"membersCount" cborgen:"membersCount"`
-	PostsCount     int64                    `json:"postsCount" cborgen:"postsCount"`
 	Did            string                   `json:"did" cborgen:"did"`
 	Declaration    *SystemDeclRef           `json:"declaration" cborgen:"declaration"`
-	Handle         string                   `json:"handle" cborgen:"handle"`
 	MyState        *ActorGetProfile_MyState `json:"myState" cborgen:"myState"`
-	Creator        string                   `json:"creator" cborgen:"creator"`
-	DisplayName    *string                  `json:"displayName" cborgen:"displayName"`
 	FollowsCount   int64                    `json:"followsCount" cborgen:"followsCount"`
+	PostsCount     int64                    `json:"postsCount" cborgen:"postsCount"`
 }
 
 type ActorGetProfile_MyState struct {
-	Follow string `json:"follow" cborgen:"follow"`
-	Member string `json:"member" cborgen:"member"`
+	Follow *string `json:"follow" cborgen:"follow"`
+	Member *string `json:"member" cborgen:"member"`
 }
 
 func ActorGetProfile(ctx context.Context, c *xrpc.Client, actor string) (*ActorGetProfile_Output, error) {

api/bsky/actorgetSuggestions.go

···
 }
 
 type ActorGetSuggestions_Actor struct {
-	MyState     *ActorGetSuggestions_MyState `json:"myState" cborgen:"myState"`
 	Did         string                       `json:"did" cborgen:"did"`
 	Declaration *SystemDeclRef               `json:"declaration" cborgen:"declaration"`
 	Handle      string                       `json:"handle" cborgen:"handle"`
 	DisplayName *string                      `json:"displayName" cborgen:"displayName"`
 	Description *string                      `json:"description" cborgen:"description"`
 	IndexedAt   *string                      `json:"indexedAt" cborgen:"indexedAt"`
+	MyState     *ActorGetSuggestions_MyState `json:"myState" cborgen:"myState"`
 }
 
 type ActorGetSuggestions_MyState struct {
-	Follow string `json:"follow" cborgen:"follow"`
+	Follow *string `json:"follow" cborgen:"follow"`
 }
 
 func ActorGetSuggestions(ctx context.Context, c *xrpc.Client, cursor string, limit int64) (*ActorGetSuggestions_Output, error) {

api/bsky/actorref.go

···
 }
 
 type ActorRef_WithInfo struct {
-	Did         string         `json:"did" cborgen:"did"`
 	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
+	Did         string         `json:"did" cborgen:"did"`
 }

api/bsky/actorsearch.go

···
 }
 
 type ActorSearch_User struct {
+	Did         string         `json:"did" cborgen:"did"`
+	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
+	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 	Description *string        `json:"description" cborgen:"description"`
 	IndexedAt   *string        `json:"indexedAt" cborgen:"indexedAt"`
-	Did         string         `json:"did" cborgen:"did"`
-	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
-	Handle      string         `json:"handle" cborgen:"handle"`
 }
 
 func ActorSearch(ctx context.Context, c *xrpc.Client, before string, limit int64, term string) (*ActorSearch_Output, error) {

api/bsky/actorsearchTypeahead.go

···
 func init() {
 }
 
-type ActorSearchTypeahead_Output struct {
-	Users []*ActorSearchTypeahead_User `json:"users" cborgen:"users"`
-}
-
 type ActorSearchTypeahead_User struct {
+	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 	Did         string         `json:"did" cborgen:"did"`
 	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 	Handle      string         `json:"handle" cborgen:"handle"`
-	DisplayName *string        `json:"displayName" cborgen:"displayName"`
+}
+
+type ActorSearchTypeahead_Output struct {
+	Users []*ActorSearchTypeahead_User `json:"users" cborgen:"users"`
 }
 
 func ActorSearchTypeahead(ctx context.Context, c *xrpc.Client, limit int64, term string) (*ActorSearchTypeahead_Output, error) {

api/bsky/actorupdateProfile.go

···
 }
 
 type ActorUpdateProfile_Input struct {
-	DisplayName string `json:"displayName" cborgen:"displayName"`
-	Description string `json:"description" cborgen:"description"`
-	Did         string `json:"did" cborgen:"did"`
+	Did         *string `json:"did" cborgen:"did"`
+	DisplayName *string `json:"displayName" cborgen:"displayName"`
+	Description *string `json:"description" cborgen:"description"`
 }
 
 type ActorUpdateProfile_Output struct {

api/bsky/feedembed.go

···
 func init() {
 }
 
+type FeedEmbed_Record struct {
+	Record any                `json:"record" cborgen:"record"`
+	Type   string             `json:"type" cborgen:"type"`
+	Author *ActorRef_WithInfo `json:"author" cborgen:"author"`
+}
+
+type FeedEmbed_External struct {
+	ImageUri    string `json:"imageUri" cborgen:"imageUri"`
+	Type        string `json:"type" cborgen:"type"`
+	Uri         string `json:"uri" cborgen:"uri"`
+	Title       string `json:"title" cborgen:"title"`
+	Description string `json:"description" cborgen:"description"`
+}
+
 type FeedEmbed struct {
 	Items []*FeedEmbed_Items_Elem `json:"items" cborgen:"items"`
 }
···
 	Thumb    *util.Blob `json:"thumb" cborgen:"thumb"`
 	Original *util.Blob `json:"original" cborgen:"original"`
 }
-
-type FeedEmbed_Record struct {
-	Type   string             `json:"type" cborgen:"type"`
-	Author *ActorRef_WithInfo `json:"author" cborgen:"author"`
-	Record any                `json:"record" cborgen:"record"`
-}
-
-type FeedEmbed_External struct {
-	Uri         string `json:"uri" cborgen:"uri"`
-	Title       string `json:"title" cborgen:"title"`
-	Description string `json:"description" cborgen:"description"`
-	ImageUri    string `json:"imageUri" cborgen:"imageUri"`
-	Type        string `json:"type" cborgen:"type"`
-}

api/bsky/feedgetAuthorFeed.go

···
 }
 
 type FeedGetAuthorFeed_Output struct {
-	Feed   []*FeedGetAuthorFeed_FeedItem `json:"feed" cborgen:"feed"`
 	Cursor *string                       `json:"cursor" cborgen:"cursor"`
+	Feed   []*FeedGetAuthorFeed_FeedItem `json:"feed" cborgen:"feed"`
 }
 
 type FeedGetAuthorFeed_FeedItem struct {
-	IndexedAt     string                     `json:"indexedAt" cborgen:"indexedAt"`
-	RepostedBy    *ActorRef_WithInfo         `json:"repostedBy" cborgen:"repostedBy"`
 	ReplyCount    int64                      `json:"replyCount" cborgen:"replyCount"`
+	UpvoteCount   int64                      `json:"upvoteCount" cborgen:"upvoteCount"`
+	MyState       *FeedGetAuthorFeed_MyState `json:"myState" cborgen:"myState"`
+	Uri           string                     `json:"uri" cborgen:"uri"`
 	Author        *ActorRef_WithInfo         `json:"author" cborgen:"author"`
-	TrendedBy     *ActorRef_WithInfo         `json:"trendedBy" cborgen:"trendedBy"`
+	RepostedBy    *ActorRef_WithInfo         `json:"repostedBy" cborgen:"repostedBy"`
 	Record        any                        `json:"record" cborgen:"record"`
 	Embed         *FeedEmbed                 `json:"embed" cborgen:"embed"`
-	RepostCount   int64                      `json:"repostCount" cborgen:"repostCount"`
-	UpvoteCount   int64                      `json:"upvoteCount" cborgen:"upvoteCount"`
-	Uri           string                     `json:"uri" cborgen:"uri"`
 	Cid           string                     `json:"cid" cborgen:"cid"`
+	TrendedBy     *ActorRef_WithInfo         `json:"trendedBy" cborgen:"trendedBy"`
+	RepostCount   int64                      `json:"repostCount" cborgen:"repostCount"`
 	DownvoteCount int64                      `json:"downvoteCount" cborgen:"downvoteCount"`
-	MyState       *FeedGetAuthorFeed_MyState `json:"myState" cborgen:"myState"`
+	IndexedAt     string                     `json:"indexedAt" cborgen:"indexedAt"`
 }
 
 type FeedGetAuthorFeed_MyState struct {
-	Repost   string `json:"repost" cborgen:"repost"`
-	Upvote   string `json:"upvote" cborgen:"upvote"`
-	Downvote string `json:"downvote" cborgen:"downvote"`
+	Downvote *string `json:"downvote" cborgen:"downvote"`
+	Repost   *string `json:"repost" cborgen:"repost"`
+	Upvote   *string `json:"upvote" cborgen:"upvote"`
 }
 
 func FeedGetAuthorFeed(ctx context.Context, c *xrpc.Client, author string, before string, limit int64) (*FeedGetAuthorFeed_Output, error) {

api/bsky/feedgetPostThread.go

···
 func init() {
 }
 
+type FeedGetPostThread_NotFoundPost struct {
+	Uri      string `json:"uri" cborgen:"uri"`
+	NotFound bool   `json:"notFound" cborgen:"notFound"`
+}
+
+type FeedGetPostThread_MyState struct {
+	Repost   *string `json:"repost" cborgen:"repost"`
+	Upvote   *string `json:"upvote" cborgen:"upvote"`
+	Downvote *string `json:"downvote" cborgen:"downvote"`
+}
+
 type FeedGetPostThread_Output struct {
 	Thread *FeedGetPostThread_Output_Thread `json:"thread" cborgen:"thread"`
 }
···
 }
 
 type FeedGetPostThread_Post struct {
+	MyState       *FeedGetPostThread_MyState             `json:"myState" cborgen:"myState"`
+	Uri           string                                 `json:"uri" cborgen:"uri"`
+	Parent        *FeedGetPostThread_Post_Parent         `json:"parent" cborgen:"parent"`
+	ReplyCount    int64                                  `json:"replyCount" cborgen:"replyCount"`
+	Replies       []*FeedGetPostThread_Post_Replies_Elem `json:"replies" cborgen:"replies"`
+	UpvoteCount   int64                                  `json:"upvoteCount" cborgen:"upvoteCount"`
 	DownvoteCount int64                                  `json:"downvoteCount" cborgen:"downvoteCount"`
 	IndexedAt     string                                 `json:"indexedAt" cborgen:"indexedAt"`
-	Replies       []*FeedGetPostThread_Post_Replies_Elem `json:"replies" cborgen:"replies"`
-	Uri           string                                 `json:"uri" cborgen:"uri"`
 	Cid           string                                 `json:"cid" cborgen:"cid"`
 	Author        *ActorRef_WithInfo                     `json:"author" cborgen:"author"`
 	Record        any                                    `json:"record" cborgen:"record"`
 	Embed         *FeedEmbed                             `json:"embed" cborgen:"embed"`
-	Parent        *FeedGetPostThread_Post_Parent         `json:"parent" cborgen:"parent"`
-	ReplyCount    int64                                  `json:"replyCount" cborgen:"replyCount"`
 	RepostCount   int64                                  `json:"repostCount" cborgen:"repostCount"`
-	UpvoteCount   int64                                  `json:"upvoteCount" cborgen:"upvoteCount"`
-	MyState       *FeedGetPostThread_MyState             `json:"myState" cborgen:"myState"`
 }
 
 type FeedGetPostThread_Post_Parent struct {
···
 	default:
 		return nil
 	}
-}
-
-type FeedGetPostThread_NotFoundPost struct {
-	Uri      string `json:"uri" cborgen:"uri"`
-	NotFound bool   `json:"notFound" cborgen:"notFound"`
-}
-
-type FeedGetPostThread_MyState struct {
-	Repost   string `json:"repost" cborgen:"repost"`
-	Upvote   string `json:"upvote" cborgen:"upvote"`
-	Downvote string `json:"downvote" cborgen:"downvote"`
 }
 
 func FeedGetPostThread(ctx context.Context, c *xrpc.Client, depth int64, uri string) (*FeedGetPostThread_Output, error) {

api/bsky/feedgetRepostedBy.go

···
 }
 
 type FeedGetRepostedBy_Output struct {
+	Cursor     *string                         `json:"cursor" cborgen:"cursor"`
+	RepostedBy []*FeedGetRepostedBy_RepostedBy `json:"repostedBy" cborgen:"repostedBy"`
 	Uri        string                          `json:"uri" cborgen:"uri"`
 	Cid        *string                         `json:"cid" cborgen:"cid"`
-	Cursor     *string                         `json:"cursor" cborgen:"cursor"`
-	RepostedBy []*FeedGetRepostedBy_RepostedBy `json:"repostedBy" cborgen:"repostedBy"`
 }
 
 type FeedGetRepostedBy_RepostedBy struct {

api/bsky/feedgetTimeline.go

···
 func init() {
 }
 
-type FeedGetTimeline_MyState struct {
-	Repost   string `json:"repost" cborgen:"repost"`
-	Upvote   string `json:"upvote" cborgen:"upvote"`
-	Downvote string `json:"downvote" cborgen:"downvote"`
-}
-
 type FeedGetTimeline_Output struct {
 	Cursor *string                     `json:"cursor" cborgen:"cursor"`
 	Feed   []*FeedGetTimeline_FeedItem `json:"feed" cborgen:"feed"`
 }
 
 type FeedGetTimeline_FeedItem struct {
+	IndexedAt     string                   `json:"indexedAt" cborgen:"indexedAt"`
+	Uri           string                   `json:"uri" cborgen:"uri"`
+	Record        any                      `json:"record" cborgen:"record"`
 	ReplyCount    int64                    `json:"replyCount" cborgen:"replyCount"`
-	TrendedBy     *ActorRef_WithInfo       `json:"trendedBy" cborgen:"trendedBy"`
 	RepostedBy    *ActorRef_WithInfo       `json:"repostedBy" cborgen:"repostedBy"`
 	Embed         *FeedEmbed               `json:"embed" cborgen:"embed"`
-	Record        any                      `json:"record" cborgen:"record"`
 	RepostCount   int64                    `json:"repostCount" cborgen:"repostCount"`
 	UpvoteCount   int64                    `json:"upvoteCount" cborgen:"upvoteCount"`
 	DownvoteCount int64                    `json:"downvoteCount" cborgen:"downvoteCount"`
-	IndexedAt     string                   `json:"indexedAt" cborgen:"indexedAt"`
-	Uri           string                   `json:"uri" cborgen:"uri"`
 	Cid           string                   `json:"cid" cborgen:"cid"`
 	Author        *ActorRef_WithInfo       `json:"author" cborgen:"author"`
+	TrendedBy     *ActorRef_WithInfo       `json:"trendedBy" cborgen:"trendedBy"`
 	MyState       *FeedGetTimeline_MyState `json:"myState" cborgen:"myState"`
+}
+
+type FeedGetTimeline_MyState struct {
+	Repost   *string `json:"repost" cborgen:"repost"`
+	Upvote   *string `json:"upvote" cborgen:"upvote"`
+	Downvote *string `json:"downvote" cborgen:"downvote"`
 }
 
 func FeedGetTimeline(ctx context.Context, c *xrpc.Client, algorithm string, before string, limit int64) (*FeedGetTimeline_Output, error) {

api/bsky/feedgetVotes.go

···
 }
 
 type FeedGetVotes_Vote struct {
+	Actor     *ActorRef_WithInfo `json:"actor" cborgen:"actor"`
 	Direction string             `json:"direction" cborgen:"direction"`
 	IndexedAt string             `json:"indexedAt" cborgen:"indexedAt"`
 	CreatedAt string             `json:"createdAt" cborgen:"createdAt"`
-	Actor     *ActorRef_WithInfo `json:"actor" cborgen:"actor"`
 }
 
 func FeedGetVotes(ctx context.Context, c *xrpc.Client, before string, cid string, direction string, limit int64, uri string) (*FeedGetVotes_Output, error) {

api/bsky/feedpost.go

···
 	util.RegisterType("app.bsky.feed.post", FeedPost{})
 }
 
-// RECORDTYPE: FeedPost
-type FeedPost struct {
-	LexiconTypeID string             `json:"$type" cborgen:"$type,const=app.bsky.feed.post"`
-	Text          string             `json:"text" cborgen:"text"`
-	Entities      []*FeedPost_Entity `json:"entities" cborgen:"entities"`
-	Reply         *FeedPost_ReplyRef `json:"reply" cborgen:"reply"`
-	CreatedAt     string             `json:"createdAt" cborgen:"createdAt"`
-}
-
 type FeedPost_ReplyRef struct {
 	Root   *comatprototypes.RepoStrongRef `json:"root" cborgen:"root"`
 	Parent *comatprototypes.RepoStrongRef `json:"parent" cborgen:"parent"`
···
 }
 
 type FeedPost_TextSlice struct {
+	Start int64 `json:"start" cborgen:"start"`
 	End   int64 `json:"end" cborgen:"end"`
-	Start int64 `json:"start" cborgen:"start"`
+}
+
+// RECORDTYPE: FeedPost
+type FeedPost struct {
+	LexiconTypeID string             `json:"$type" cborgen:"$type,const=app.bsky.feed.post"`
+	Text          string             `json:"text" cborgen:"text"`
+	Entities      []*FeedPost_Entity `json:"entities" cborgen:"entities"`
+	Reply         *FeedPost_ReplyRef `json:"reply" cborgen:"reply"`
+	CreatedAt     string             `json:"createdAt" cborgen:"createdAt"`
 }

api/bsky/feedsetVote.go

···
 }
 
 type FeedSetVote_Output struct {
-	Upvote   string `json:"upvote" cborgen:"upvote"`
-	Downvote string `json:"downvote" cborgen:"downvote"`
+	Upvote   *string `json:"upvote" cborgen:"upvote"`
+	Downvote *string `json:"downvote" cborgen:"downvote"`
 }
 
 func FeedSetVote(ctx context.Context, c *xrpc.Client, input FeedSetVote_Input) (*FeedSetVote_Output, error) {

api/bsky/graphassertion.go

···
 // RECORDTYPE: GraphAssertion
 type GraphAssertion struct {
 	LexiconTypeID string    `json:"$type" cborgen:"$type,const=app.bsky.graph.assertion"`
+	Subject       *ActorRef `json:"subject" cborgen:"subject"`
 	CreatedAt     string    `json:"createdAt" cborgen:"createdAt"`
 	Assertion     string    `json:"assertion" cborgen:"assertion"`
-	Subject       *ActorRef `json:"subject" cborgen:"subject"`
 }

api/bsky/graphfollow.go

···
 // RECORDTYPE: GraphFollow
 type GraphFollow struct {
 	LexiconTypeID string    `json:"$type" cborgen:"$type,const=app.bsky.graph.follow"`
-	Subject       *ActorRef `json:"subject" cborgen:"subject"`
 	CreatedAt     string    `json:"createdAt" cborgen:"createdAt"`
+	Subject       *ActorRef `json:"subject" cborgen:"subject"`
 }

api/bsky/graphgetAssertions.go

···
 }
 
 type GraphGetAssertions_Assertion struct {
-	Cid          string                           `json:"cid" cborgen:"cid"`
 	Assertion    string                           `json:"assertion" cborgen:"assertion"`
 	Confirmation *GraphGetAssertions_Confirmation `json:"confirmation" cborgen:"confirmation"`
 	Author       *ActorRef_WithInfo               `json:"author" cborgen:"author"`
···
 	IndexedAt    string                           `json:"indexedAt" cborgen:"indexedAt"`
 	CreatedAt    string                           `json:"createdAt" cborgen:"createdAt"`
 	Uri          string                           `json:"uri" cborgen:"uri"`
+	Cid          string                           `json:"cid" cborgen:"cid"`
 }
 
 type GraphGetAssertions_Confirmation struct {

api/bsky/graphgetFollowers.go

···
 }
 
 type GraphGetFollowers_Output struct {
+	Followers []*GraphGetFollowers_Follower `json:"followers" cborgen:"followers"`
 	Subject   *GraphGetFollowers_Subject    `json:"subject" cborgen:"subject"`
 	Cursor    *string                       `json:"cursor" cborgen:"cursor"`
-	Followers []*GraphGetFollowers_Follower `json:"followers" cborgen:"followers"`
 }
 
 type GraphGetFollowers_Subject struct {
-	Did         string         `json:"did" cborgen:"did"`
-	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
+	Did         string         `json:"did" cborgen:"did"`
+	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 }
 
 type GraphGetFollowers_Follower struct {
+	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
+	Handle      string         `json:"handle" cborgen:"handle"`
+	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 	CreatedAt   *string        `json:"createdAt" cborgen:"createdAt"`
 	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
 	Did         string         `json:"did" cborgen:"did"`
-	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
-	Handle      string         `json:"handle" cborgen:"handle"`
-	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 }
 
 func GraphGetFollowers(ctx context.Context, c *xrpc.Client, before string, limit int64, user string) (*GraphGetFollowers_Output, error) {

api/bsky/graphgetFollows.go

···
 }
 
 type GraphGetFollows_Output struct {
+	Subject *ActorRef_WithInfo        `json:"subject" cborgen:"subject"`
 	Cursor  *string                   `json:"cursor" cborgen:"cursor"`
 	Follows []*GraphGetFollows_Follow `json:"follows" cborgen:"follows"`
-	Subject *ActorRef_WithInfo        `json:"subject" cborgen:"subject"`
 }
 
 type GraphGetFollows_Follow struct {
+	CreatedAt   *string        `json:"createdAt" cborgen:"createdAt"`
+	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
 	Did         string         `json:"did" cborgen:"did"`
 	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
-	CreatedAt   *string        `json:"createdAt" cborgen:"createdAt"`
-	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
 }
 
 func GraphGetFollows(ctx context.Context, c *xrpc.Client, before string, limit int64, user string) (*GraphGetFollows_Output, error) {

api/bsky/graphgetMembers.go

···
 }
 
 type GraphGetMembers_Output struct {
-	Subject *ActorRef_WithInfo        `json:"subject" cborgen:"subject"`
 	Cursor  *string                   `json:"cursor" cborgen:"cursor"`
 	Members []*GraphGetMembers_Member `json:"members" cborgen:"members"`
+	Subject *ActorRef_WithInfo        `json:"subject" cborgen:"subject"`
 }
 
 type GraphGetMembers_Member struct {
-	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
-	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 	CreatedAt   *string        `json:"createdAt" cborgen:"createdAt"`
 	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
 	Did         string         `json:"did" cborgen:"did"`
+	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
+	Handle      string         `json:"handle" cborgen:"handle"`
 }
 
 func GraphGetMembers(ctx context.Context, c *xrpc.Client, actor string, before string, limit int64) (*GraphGetMembers_Output, error) {

api/bsky/graphgetMemberships.go

···
 }
 
 type GraphGetMemberships_Membership struct {
-	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
-	Did         string         `json:"did" cborgen:"did"`
 	Declaration *SystemDeclRef `json:"declaration" cborgen:"declaration"`
 	Handle      string         `json:"handle" cborgen:"handle"`
 	DisplayName *string        `json:"displayName" cborgen:"displayName"`
 	CreatedAt   *string        `json:"createdAt" cborgen:"createdAt"`
+	IndexedAt   string         `json:"indexedAt" cborgen:"indexedAt"`
+	Did         string         `json:"did" cborgen:"did"`
 }
 
 func GraphGetMemberships(ctx context.Context, c *xrpc.Client, actor string, before string, limit int64) (*GraphGetMemberships_Output, error) {

api/bsky/systemdeclRef.go

···
 }
 
 type SystemDeclRef struct {
-	ActorType string `json:"actorType" cborgen:"actorType"`
 	Cid       string `json:"cid" cborgen:"cid"`
+	ActorType string `json:"actorType" cborgen:"actorType"`
 }

api/server/auth.go

···
 
 import (
 	"context"
+	"crypto/rand"
+	"encoding/base64"
 	"time"
 
 	"github.com/lestrrat-go/jwx/jwa"
···
 func (s *Server) createAuthTokenForUser(ctx context.Context, handle, did string) (*xrpc.AuthInfo, error) {
 	accessTok := makeToken(did, "com.atproto.access", time.Now().Add(24*time.Hour))
 	refreshTok := makeToken(did, "com.atproto.refresh", time.Now().Add(7*24*time.Hour))
+
+	rval := make([]byte, 10)
+	rand.Read(rval)
+	refreshTok.Set("jti", base64.StdEncoding.EncodeToString(rval))
 
 	accSig, err := jwt.Sign(accessTok, jwa.HS256, s.signingKey)
 	if err != nil {

api/server/feedgen.go

···
 
 type FeedPost struct {
 	gorm.Model
-	Author      uint
-	RepostedBy  uint
-	TrendedBy   uint
-	Tid         string
+	Author     uint
+	RepostedBy uint
+	TrendedBy  uint
+	// TODO: only keeping rkey here, assuming collection is app.bsky.feed.post
+	Rkey        string
 	Cid         string
 	UpCount     int64
 	ReplyCount  int64
···
 
 type ActorInfo struct {
 	gorm.Model
-	User       uint `gorm:"index"`
-	Handle     string
-	Did        string
-	Name       string
-	Following  int
-	Followers  int
-	Posts      int
-	DeclRefCid string
-	Type       string
+	User        uint `gorm:"index"`
+	Handle      string
+	DisplayName string
+	Did         string
+	Name        string
+	Following   int64
+	Followers   int64
+	Posts       int64
+	DeclRefCid  string
+	Type        string
+}
+
+type VoteDir int
+
+func (vd VoteDir) String() string {
+	switch vd {
+	case VoteDirUp:
+		return "up"
+	case VoteDirDown:
+		return "down"
+	default:
+		return "<unknown>"
+	}
 }
 
-type UpVoteRecord struct {
+const (
+	VoteDirUp   = VoteDir(1)
+	VoteDirDown = VoteDir(2)
+)
+
+type VoteRecord struct {
 	gorm.Model
-	User  uint
-	Likes uint
+	Dir     VoteDir
+	User    uint
+	Post    uint
+	Created string
 }
 
 type FollowRecord struct {
···
 	db.AutoMigrate(&FeedPost{})
 	db.AutoMigrate(&ActorInfo{})
 	db.AutoMigrate(&FollowRecord{})
-	db.AutoMigrate(&UpVoteRecord{})
+	db.AutoMigrate(&VoteRecord{})
 
 	return &FeedGenerator{
 		db:         db,
···
 		return "", err
 	}
 
-	return ai.Handle, nil
+	return ai.Did, nil
 }
 
 func (fg *FeedGenerator) getActorRefInfo(ctx context.Context, user uint) (*bsky.ActorRef_WithInfo, error) {
···
 	}
 
 	out := HydratedFeedItem{
-		Uri:           "at://" + authorDid + "/" + item.Tid,
+		Uri:           "at://" + authorDid + "/app.bsky.feed.post/" + item.Rkey,
 		ReplyCount:    item.ReplyCount,
 		RepostCount:   item.RepostCount,
 		UpvoteCount:   item.UpCount,
···
 }
 
 type parsedUri struct {
-	Did  string
-	Rkey string
+	Did        string
+	Collection string
+	Rkey       string
 }
 
 func parseAtUri(uri string) (*parsedUri, error) {
···
 		return nil, fmt.Errorf("AT uris must have three parts: did, collection, tid")
 	}
 
-	did := parts[0]
-	rkey := parts[1] + "/" + parts[2]
-
 	return &parsedUri{
-		Did:  did,
-		Rkey: rkey,
+		Did:        parts[0],
+		Collection: parts[1],
+		Rkey:       parts[2],
 	}, nil
 }
 
···
 	switch rec := evt.Record.(type) {
 	case *bsky.FeedPost:
 		fp := FeedPost{
-			Tid:    evt.Rkey,
+			Rkey:   evt.Rkey,
 			Cid:    evt.RecCid.String(),
 			Author: evt.User,
 		}
···
 		return nil
 	case *bsky.FeedVote:
 		var val int
+		var dbdir VoteDir
 		switch rec.Direction {
 		case "up":
 			val = 1
+			dbdir = VoteDirUp
 		case "down":
 			val = -1
+			dbdir = VoteDirDown
 		default:
 			return fmt.Errorf("invalid vote direction: %q", rec.Direction)
 		}
···
 		}
 
 		var post FeedPost
-		if err := fg.db.First(&post, "tid = ? AND author = ?", puri.Rkey, act.User).Error; err != nil {
+		if err := fg.db.First(&post, "rkey = ? AND author = ?", puri.Rkey, act.User).Error; err != nil {
 			return err
 		}
 
-		if err := fg.db.Create(&UpVoteRecord{
-			User:  evt.User,
-			Likes: post.ID,
+		if err := fg.db.Create(&VoteRecord{
+			Dir:     dbdir,
+			User:    evt.User,
+			Post:    post.ID,
+			Created: rec.CreatedAt,
 		}).Error; err != nil {
 			return err
 		}
···
 
 func (fg *FeedGenerator) GetActorProfile(ctx context.Context, actor string) (*ActorInfo, error) {
 	var ai ActorInfo
-	if err := fg.db.First(&ai, "handle = ?", actor).Error; err != nil {
+	if strings.HasPrefix(actor, "did:") {
+		if err := fg.db.First(&ai, "did = ?", actor).Error; err != nil {
+			return nil, err
+		}
+	} else {
+		if err := fg.db.First(&ai, "handle = ?", actor).Error; err != nil {
+			return nil, err
+		}
+	}
+
+	return &ai, nil
+}
+
+func (fg *FeedGenerator) GetPost(ctx context.Context, uri string) (*FeedPost, error) {
+	puri, err := parseAtUri(uri)
+	if err != nil {
+		return nil, err
+	}
+
+	var post FeedPost
+	if err := fg.db.First(&post, "rkey = ? AND author = (?)", puri.Rkey, fg.db.Model(ActorInfo{}).Where("did = ?", puri.Did).Select("id")).Error; err != nil {
+		return nil, err
+	}
+
+	return &post, nil
+}
+
+type ThreadPost struct {
+	Post *HydratedFeedItem
+
+	ParentUri string
+	Parent    *ThreadPost
+}
+
+func (fg *FeedGenerator) GetPostThread(ctx context.Context, uri string, depth int) (*ThreadPost, error) {
+	post, err := fg.GetPost(ctx, uri)
+	if err != nil {
+		return nil, fmt.Errorf("getting post for thread: %w", err)
+	}
+
+	hi, err := fg.hydrateItem(ctx, post)
+	if err != nil {
 		return nil, err
 	}
 
-	return nil, nil
+	p, ok := hi.Record.(*bsky.FeedPost)
+	if !ok {
+		return nil, fmt.Errorf("getPostThread can only operate on app.bsky.feed.post records")
+	}
+
+	out := &ThreadPost{
+		Post: hi,
+	}
+
+	if p.Reply != nil {
+		out.ParentUri = p.Reply.Parent.Uri
+		if depth > 0 {
+
+			parent, err := fg.GetPostThread(ctx, p.Reply.Parent.Uri, depth-1)
+			if err != nil {
+				// TODO: check for and handle 'not found'
+				return nil, err
+			}
+			out.Parent = parent
+		}
+	}
+
+	return out, nil
+}
+
+type HydratedVote struct {
+	Actor     *bsky.ActorRef_WithInfo
+	Direction string
+	IndexedAt time.Time
+	CreatedAt string
+}
+
+func (fg *FeedGenerator) hydrateVote(ctx context.Context, v *VoteRecord) (*HydratedVote, error) {
+	aref, err := fg.getActorRefInfo(ctx, v.User)
+	if err != nil {
+		return nil, err
+	}
+
+	return &HydratedVote{
+		Actor:     aref,
+		Direction: v.Dir.String(),
+		IndexedAt: v.UpdatedAt,
+		CreatedAt: v.Created,
+	}, nil
+}
+
+func (fg *FeedGenerator) GetVotes(ctx context.Context, uri string, pcid cid.Cid, dir string, limit int, before string) ([]*HydratedVote, error) {
+	if before != "" {
+		log.Println("not respecting 'before' yet")
+	}
+
+	p, err := fg.GetPost(ctx, uri)
+	if err != nil {
+		return nil, err
+	}
+
+	if p.Cid != pcid.String() {
+		return nil, fmt.Errorf("listing likes of old post versions not supported")
+	}
+
+	var dbdir VoteDir
+	switch dir {
+	case "up":
+		dbdir = VoteDirUp
+	case "down":
+		dbdir = VoteDirDown
+	default:
+		return nil, fmt.Errorf("there are only two directions, up or down")
+	}
+
+	var voterecs []VoteRecord
+	if err := fg.db.Limit(limit).Find(&voterecs, "dir = ? AND post = ?", dbdir, p.ID).Error; err != nil {
+		return nil, err
+	}
+
+	var out []*HydratedVote
+	for _, vr := range voterecs {
+		hv, err := fg.hydrateVote(ctx, &vr)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, hv)
+	}
+
+	return out, nil
 }

api/server/handlers.go

···
 }
 
 func (s *Server) handleAppBskyActorGetProfile(ctx context.Context, actor string) (*appbskytypes.ActorGetProfile_Output, error) {
-	fmt.Println("Get profile:", actor)
-
-	return nil, nil
-
-	/*
-			profile, err := s.feedgen.GetActorProfile(ctx, actor)
-			if err != nil {
-				return nil, err
-			}
+	profile, err := s.feedgen.GetActorProfile(ctx, actor)
+	if err != nil {
+		return nil, err
+	}
 
-			var out appbskytypes.ActorGetProfile_Output
-			out := ActorGetProfile_Output {
-				MyState     : nil, //*ActorGetProfile_MyState `json:"myState" cborgen:"myState"`
-			Did            string                   `json:"did" cborgen:"did"`
-			Declaration    *SystemDeclRef           `json:"declaration" cborgen:"declaration"`
-			Description    string                   `json:"description" cborgen:"description"`
-			PostsCount     int64                    `json:"postsCount" cborgen:"postsCount"`
-			FollowsCount   int64                    `json:"followsCount" cborgen:"followsCount"`
-			MembersCount   int64                    `json:"membersCount" cborgen:"membersCount"`
-			Handle         string                   `json:"handle" cborgen:"handle"`
-			Creator        string                   `json:"creator" cborgen:"creator"`
-			DisplayName    string                   `json:"displayName" cborgen:"displayName"`
-			FollowersCount int64                    `json:"followersCount" cborgen:"followersCount"`
-		}
-	*/
+	return &appbskytypes.ActorGetProfile_Output{
+		MyState: nil, //*ActorGetProfile_MyState `json:"myState" cborgen:"myState"`
+		Did:     profile.Did,
+		Declaration: &appbskytypes.SystemDeclRef{
+			Cid:       profile.DeclRefCid,
+			ActorType: profile.Type,
+		},
+		Description:    nil,
+		PostsCount:     profile.Posts,
+		FollowsCount:   profile.Following,
+		MembersCount:   0, // TODO:
+		Handle:         profile.Handle,
+		Creator:        "", //TODO:
+		DisplayName:    &profile.DisplayName,
+		FollowersCount: profile.Followers,
+	}, nil
 }
 
 func (s *Server) handleAppBskyActorGetSuggestions(ctx context.Context, cursor string, limit int) (*appbskytypes.ActorGetSuggestions_Output, error) {
···
 	return &out, nil
 }
 
-func (s *Server) handleAppBskyFeedGetPostThread(ctx context.Context, depth int, uri string) (*appbskytypes.FeedGetPostThread_Output, error) {
-	panic("not yet implemented")
+func (s *Server) handleAppBskyFeedGetPostThread(ctx context.Context, depth *int, uri string) (*appbskytypes.FeedGetPostThread_Output, error) {
+
+	d := 6
+	if depth != nil {
+		d = *depth
+	}
+
+	pthread, err := s.feedgen.GetPostThread(ctx, uri, d)
+	if err != nil {
+		return nil, err
+	}
+
+	var convertToOutputType func(thr *ThreadPost) *appbskytypes.FeedGetPostThread_Post
+	convertToOutputType = func(thr *ThreadPost) *appbskytypes.FeedGetPostThread_Post {
+		p := thr.Post
+		out := &appbskytypes.FeedGetPostThread_Post{
+			MyState:       nil, // TODO:
+			Uri:           p.Uri,
+			Parent:        nil,
+			ReplyCount:    p.ReplyCount,
+			Replies:       []*appbskytypes.FeedGetPostThread_Post_Replies_Elem{},
+			UpvoteCount:   p.UpvoteCount,
+			DownvoteCount: 0, // TODO:
+			IndexedAt:     p.IndexedAt,
+			Cid:           p.Cid,
+			Author:        p.Author,
+			Record:        p.Record,
+			Embed:         nil, // TODO: embeds
+			RepostCount:   p.RepostCount,
+		}
+
+		if thr.ParentUri != "" {
+			if thr.Parent == nil {
+				out.Parent = &appbskytypes.FeedGetPostThread_Post_Parent{
+					FeedGetPostThread_NotFoundPost: &appbskytypes.FeedGetPostThread_NotFoundPost{
+						Uri:      thr.ParentUri,
+						NotFound: true,
+					},
+				}
+			} else {
+				out.Parent = &appbskytypes.FeedGetPostThread_Post_Parent{
+					FeedGetPostThread_Post: convertToOutputType(thr.Parent),
+				}
+			}
+		}
+
+		return out
+	}
+
+	out := appbskytypes.FeedGetPostThread_Output{
+		Thread: &appbskytypes.FeedGetPostThread_Output_Thread{
+			FeedGetPostThread_Post: convertToOutputType(pthread),
+			//FeedGetPostThread_NotFoundPost: &appbskytypes.FeedGetPostThread_NotFoundPost{},
+		},
+	}
+
+	return &out, nil
 }
 
 func (s *Server) handleAppBskyFeedGetRepostedBy(ctx context.Context, before string, cid string, limit int, uri string) (*appbskytypes.FeedGetRepostedBy_Output, error) {
···
 	return &out, nil
 }
 
-func (s *Server) handleAppBskyFeedGetVotes(ctx context.Context, before string, cid string, direction string, limit int, uri string) (*appbskytypes.FeedGetVotes_Output, error) {
-	panic("not yet implemented")
+func (s *Server) handleAppBskyFeedGetVotes(ctx context.Context, before string, cc string, direction string, limit int, uri string) (*appbskytypes.FeedGetVotes_Output, error) {
+	pcid, err := cid.Decode(cc)
+	if err != nil {
+		return nil, err
+	}
+
+	votes, err := s.feedgen.GetVotes(ctx, uri, pcid, direction, limit, before)
+	if err != nil {
+		return nil, err
+	}
+
+	var out appbskytypes.FeedGetVotes_Output
+	out.Uri = uri
+	out.Votes = []*appbskytypes.FeedGetVotes_Vote{}
+
+	for _, v := range votes {
+		out.Votes = append(out.Votes, &appbskytypes.FeedGetVotes_Vote{
+			Actor:     v.Actor,
+			Direction: v.Direction,
+			IndexedAt: v.IndexedAt.Format(time.RFC3339),
+			CreatedAt: v.CreatedAt,
+		})
+	}
+
+	return &out, nil
 }
 
 func (s *Server) handleAppBskyFeedSetVote(ctx context.Context, input *appbskytypes.FeedSetVote_Input) (*appbskytypes.FeedSetVote_Output, error) {
···
 }
 
 func (s *Server) handleAppBskyGraphGetMemberships(ctx context.Context, actor string, before string, limit int) (*appbskytypes.GraphGetMemberships_Output, error) {
-	panic("not yet implemented")
+	ai, err := s.feedgen.GetActorProfile(ctx, actor)
+	if err != nil {
+		return nil, err
+	}
+
+	return &appbskytypes.GraphGetMemberships_Output{
+		Subject:     infoToActorRef(ai),
+		Memberships: []*appbskytypes.GraphGetMemberships_Membership{},
+	}, nil
 }
 
 func (s *Server) handleAppBskyNotificationGetCount(ctx context.Context) (*appbskytypes.NotificationGetCount_Output, error) {
···
 
 	if err := s.validateHandle(input.Handle); err != nil {
 		return nil, err
+	}
 
+	_, err := s.lookupUserByHandle(ctx, input.Handle)
+	switch err {
+	default:
+		return nil, err
+	case nil:
+		return nil, fmt.Errorf("handle already registered")
+	case ErrNoSuchUser:
+		// handle is available, lets go
 	}
 
 	var recoveryKey string
···
 		return nil, err
 	}
 
-	rkey, recid, err := s.repoman.CreateRecord(ctx, u.ID, input.Collection, rec)
+	rpath, recid, err := s.repoman.CreateRecord(ctx, u.ID, input.Collection, rec)
 	if err != nil {
 		return nil, err
 	}
 
 	return &comatprototypes.RepoCreateRecord_Output{
-		Uri: "at://" + u.DID + "/" + rkey,
+		Uri: "at://" + u.DID + "/" + rpath,
 		Cid: recid.String(),
 	}, nil
 }

api/server/server.go

···
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
 	jwk "github.com/lestrrat-go/jwx/jwk"
+	appbskytypes "github.com/whyrusleeping/gosky/api/bsky"
 	"github.com/whyrusleeping/gosky/carstore"
 	"github.com/whyrusleeping/gosky/lex/util"
 	"github.com/whyrusleeping/gosky/repomgr"
···
 	DID         string `gorm:"uniqueIndex"`
 }
 
+type RefreshToken struct {
+	gorm.Model
+	Token string
+}
+
 func toTime(i interface{}) (time.Time, error) {
 	ival, ok := i.(float64)
 	if !ok {
···
 	return &u, nil
 }
 
+var ErrNoSuchUser = fmt.Errorf("no such user")
+
 func (s *Server) lookupUserByHandle(ctx context.Context, handle string) (*User, error) {
 	var didEntry FakeDidMapping
 	if err := s.db.First(&didEntry, "handle = ?", handle).Error; err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return nil, ErrNoSuchUser
+		}
 		return nil, err
 	}
 
 	var u User
 	if err := s.db.First(&u, "handle = ?", didEntry.Handle).Error; err != nil {
 		if err == gorm.ErrRecordNotFound {
-			return nil, fmt.Errorf("no such user with handle: %s", handle)
+			return nil, ErrNoSuchUser
 		}
 		return nil, err
 	}
···
 
 	return nil
 }
+
+func infoToActorRef(ai *ActorInfo) *appbskytypes.ActorRef_WithInfo {
+	return &appbskytypes.ActorRef_WithInfo{
+		Declaration: &appbskytypes.SystemDeclRef{
+			Cid:       ai.DeclRefCid,
+			ActorType: ai.Type,
+		},
+		Handle:      ai.Handle,
+		DisplayName: &ai.DisplayName,
+		Did:         ai.Did,
+	}
+}

api/server/stubs.go

···
 	"go.opentelemetry.io/otel"
 )
 
-func (s *Server) RegisterHandlersComAtproto(e *echo.Echo) error {
-	e.POST("/xrpc/com.atproto.account.create", s.HandleComAtprotoAccountCreate)
-	e.POST("/xrpc/com.atproto.account.createInviteCode", s.HandleComAtprotoAccountCreateInviteCode)
-	e.POST("/xrpc/com.atproto.account.delete", s.HandleComAtprotoAccountDelete)
-	e.GET("/xrpc/com.atproto.account.get", s.HandleComAtprotoAccountGet)
-	e.POST("/xrpc/com.atproto.account.requestPasswordReset", s.HandleComAtprotoAccountRequestPasswordReset)
-	e.POST("/xrpc/com.atproto.account.resetPassword", s.HandleComAtprotoAccountResetPassword)
-	e.GET("/xrpc/com.atproto.handle.resolve", s.HandleComAtprotoHandleResolve)
-	e.POST("/xrpc/com.atproto.repo.batchWrite", s.HandleComAtprotoRepoBatchWrite)
-	e.POST("/xrpc/com.atproto.repo.createRecord", s.HandleComAtprotoRepoCreateRecord)
-	e.POST("/xrpc/com.atproto.repo.deleteRecord", s.HandleComAtprotoRepoDeleteRecord)
-	e.GET("/xrpc/com.atproto.repo.describe", s.HandleComAtprotoRepoDescribe)
-	e.GET("/xrpc/com.atproto.repo.getRecord", s.HandleComAtprotoRepoGetRecord)
-	e.GET("/xrpc/com.atproto.repo.listRecords", s.HandleComAtprotoRepoListRecords)
-	e.POST("/xrpc/com.atproto.repo.putRecord", s.HandleComAtprotoRepoPutRecord)
-	e.GET("/xrpc/com.atproto.server.getAccountsConfig", s.HandleComAtprotoServerGetAccountsConfig)
-	e.POST("/xrpc/com.atproto.session.create", s.HandleComAtprotoSessionCreate)
-	e.POST("/xrpc/com.atproto.session.delete", s.HandleComAtprotoSessionDelete)
-	e.GET("/xrpc/com.atproto.session.get", s.HandleComAtprotoSessionGet)
-	e.POST("/xrpc/com.atproto.session.refresh", s.HandleComAtprotoSessionRefresh)
-	e.GET("/xrpc/com.atproto.sync.getRepo", s.HandleComAtprotoSyncGetRepo)
-	e.GET("/xrpc/com.atproto.sync.getRoot", s.HandleComAtprotoSyncGetRoot)
-	e.POST("/xrpc/com.atproto.sync.updateRepo", s.HandleComAtprotoSyncUpdateRepo)
+func (s *Server) RegisterHandlersAppBsky(e *echo.Echo) error {
+	e.POST("/xrpc/app.bsky.actor.createScene", s.HandleAppBskyActorCreateScene)
+	e.GET("/xrpc/app.bsky.actor.getProfile", s.HandleAppBskyActorGetProfile)
+	e.GET("/xrpc/app.bsky.actor.getSuggestions", s.HandleAppBskyActorGetSuggestions)
+	e.GET("/xrpc/app.bsky.actor.search", s.HandleAppBskyActorSearch)
+	e.GET("/xrpc/app.bsky.actor.searchTypeahead", s.HandleAppBskyActorSearchTypeahead)
+	e.POST("/xrpc/app.bsky.actor.updateProfile", s.HandleAppBskyActorUpdateProfile)
+	e.GET("/xrpc/app.bsky.feed.getAuthorFeed", s.HandleAppBskyFeedGetAuthorFeed)
+	e.GET("/xrpc/app.bsky.feed.getPostThread", s.HandleAppBskyFeedGetPostThread)
+	e.GET("/xrpc/app.bsky.feed.getRepostedBy", s.HandleAppBskyFeedGetRepostedBy)
+	e.GET("/xrpc/app.bsky.feed.getTimeline", s.HandleAppBskyFeedGetTimeline)
+	e.GET("/xrpc/app.bsky.feed.getVotes", s.HandleAppBskyFeedGetVotes)
+	e.POST("/xrpc/app.bsky.feed.setVote", s.HandleAppBskyFeedSetVote)
+	e.GET("/xrpc/app.bsky.graph.getAssertions", s.HandleAppBskyGraphGetAssertions)
+	e.GET("/xrpc/app.bsky.graph.getFollowers", s.HandleAppBskyGraphGetFollowers)
+	e.GET("/xrpc/app.bsky.graph.getFollows", s.HandleAppBskyGraphGetFollows)
+	e.GET("/xrpc/app.bsky.graph.getMembers", s.HandleAppBskyGraphGetMembers)
+	e.GET("/xrpc/app.bsky.graph.getMemberships", s.HandleAppBskyGraphGetMemberships)
+	e.GET("/xrpc/app.bsky.notification.getCount", s.HandleAppBskyNotificationGetCount)
+	e.GET("/xrpc/app.bsky.notification.list", s.HandleAppBskyNotificationList)
+	e.POST("/xrpc/app.bsky.notification.updateSeen", s.HandleAppBskyNotificationUpdateSeen)
 	return nil
 }
 
-func (s *Server) HandleComAtprotoAccountCreate(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountCreate")
+func (s *Server) HandleAppBskyActorCreateScene(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorCreateScene")
 	defer span.End()
 
-	var body comatprototypes.AccountCreate_Input
+	var body appbskytypes.ActorCreateScene_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *comatprototypes.AccountCreate_Output
+	var out *appbskytypes.ActorCreateScene_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoAccountCreate(ctx context.Context,body comatprototypes.AccountCreate_Input) (*comatprototypes.AccountCreate_Output, error)
-	out, handleErr = s.handleComAtprotoAccountCreate(ctx, &body)
+	// func (s *Server) handleAppBskyActorCreateScene(ctx context.Context,body appbskytypes.ActorCreateScene_Input) (*appbskytypes.ActorCreateScene_Output, error)
+	out, handleErr = s.handleAppBskyActorCreateScene(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAccountCreateInviteCode(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountCreateInviteCode")
+func (s *Server) HandleAppBskyActorGetProfile(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorGetProfile")
 	defer span.End()
-
-	var body comatprototypes.AccountCreateInviteCode_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
-	var out *comatprototypes.AccountCreateInviteCode_Output
+	actor := c.QueryParam("actor")
+	var out *appbskytypes.ActorGetProfile_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoAccountCreateInviteCode(ctx context.Context,body comatprototypes.AccountCreateInviteCode_Input) (*comatprototypes.AccountCreateInviteCode_Output, error)
-	out, handleErr = s.handleComAtprotoAccountCreateInviteCode(ctx, &body)
+	// func (s *Server) handleAppBskyActorGetProfile(ctx context.Context,actor string) (*appbskytypes.ActorGetProfile_Output, error)
+	out, handleErr = s.handleAppBskyActorGetProfile(ctx, actor)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAccountDelete(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountDelete")
+func (s *Server) HandleAppBskyActorGetSuggestions(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorGetSuggestions")
 	defer span.End()
-	var handleErr error
-	// func (s *Server) handleComAtprotoAccountDelete(ctx context.Context) error
-	handleErr = s.handleComAtprotoAccountDelete(ctx)
-	if handleErr != nil {
-		return handleErr
+	cursor := c.QueryParam("cursor")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	return nil
-}
-
-func (s *Server) HandleComAtprotoAccountGet(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountGet")
-	defer span.End()
+	var out *appbskytypes.ActorGetSuggestions_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoAccountGet(ctx context.Context) error
-	handleErr = s.handleComAtprotoAccountGet(ctx)
+	// func (s *Server) handleAppBskyActorGetSuggestions(ctx context.Context,cursor string,limit int) (*appbskytypes.ActorGetSuggestions_Output, error)
+	out, handleErr = s.handleAppBskyActorGetSuggestions(ctx, cursor, limit)
 	if handleErr != nil {
 		return handleErr
 	}
-	return nil
+	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAccountRequestPasswordReset(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountRequestPasswordReset")
+func (s *Server) HandleAppBskyActorSearch(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorSearch")
 	defer span.End()
+	before := c.QueryParam("before")
 
-	var body comatprototypes.AccountRequestPasswordReset_Input
-	if err := c.Bind(&body); err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
+	term := c.QueryParam("term")
+	var out *appbskytypes.ActorSearch_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoAccountRequestPasswordReset(ctx context.Context,body comatprototypes.AccountRequestPasswordReset_Input) error
-	handleErr = s.handleComAtprotoAccountRequestPasswordReset(ctx, &body)
+	// func (s *Server) handleAppBskyActorSearch(ctx context.Context,before string,limit int,term string) (*appbskytypes.ActorSearch_Output, error)
+	out, handleErr = s.handleAppBskyActorSearch(ctx, before, limit, term)
 	if handleErr != nil {
 		return handleErr
 	}
-	return nil
+	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoAccountResetPassword(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountResetPassword")
+func (s *Server) HandleAppBskyActorSearchTypeahead(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorSearchTypeahead")
 	defer span.End()
 
-	var body comatprototypes.AccountResetPassword_Input
-	if err := c.Bind(&body); err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	var handleErr error
-	// func (s *Server) handleComAtprotoAccountResetPassword(ctx context.Context,body comatprototypes.AccountResetPassword_Input) error
-	handleErr = s.handleComAtprotoAccountResetPassword(ctx, &body)
-	if handleErr != nil {
-		return handleErr
-	}
-	return nil
-}
-
-func (s *Server) HandleComAtprotoHandleResolve(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoHandleResolve")
-	defer span.End()
-	handle := c.QueryParam("handle")
-	var out *comatprototypes.HandleResolve_Output
+	term := c.QueryParam("term")
+	var out *appbskytypes.ActorSearchTypeahead_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoHandleResolve(ctx context.Context,handle string) (*comatprototypes.HandleResolve_Output, error)
-	out, handleErr = s.handleComAtprotoHandleResolve(ctx, handle)
+	// func (s *Server) handleAppBskyActorSearchTypeahead(ctx context.Context,limit int,term string) (*appbskytypes.ActorSearchTypeahead_Output, error)
+	out, handleErr = s.handleAppBskyActorSearchTypeahead(ctx, limit, term)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoBatchWrite(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoBatchWrite")
+func (s *Server) HandleAppBskyActorUpdateProfile(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorUpdateProfile")
 	defer span.End()
 
-	var body comatprototypes.RepoBatchWrite_Input
+	var body appbskytypes.ActorUpdateProfile_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
+	var out *appbskytypes.ActorUpdateProfile_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoBatchWrite(ctx context.Context,body comatprototypes.RepoBatchWrite_Input) error
-	handleErr = s.handleComAtprotoRepoBatchWrite(ctx, &body)
+	// func (s *Server) handleAppBskyActorUpdateProfile(ctx context.Context,body appbskytypes.ActorUpdateProfile_Input) (*appbskytypes.ActorUpdateProfile_Output, error)
+	out, handleErr = s.handleAppBskyActorUpdateProfile(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
-	return nil
+	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoCreateRecord(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoCreateRecord")
+func (s *Server) HandleAppBskyFeedGetAuthorFeed(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetAuthorFeed")
 	defer span.End()
+	author := c.QueryParam("author")
+	before := c.QueryParam("before")
 
-	var body comatprototypes.RepoCreateRecord_Input
-	if err := c.Bind(&body); err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	var out *comatprototypes.RepoCreateRecord_Output
+	var out *appbskytypes.FeedGetAuthorFeed_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoCreateRecord(ctx context.Context,body comatprototypes.RepoCreateRecord_Input) (*comatprototypes.RepoCreateRecord_Output, error)
-	out, handleErr = s.handleComAtprotoRepoCreateRecord(ctx, &body)
+	// func (s *Server) handleAppBskyFeedGetAuthorFeed(ctx context.Context,author string,before string,limit int) (*appbskytypes.FeedGetAuthorFeed_Output, error)
+	out, handleErr = s.handleAppBskyFeedGetAuthorFeed(ctx, author, before, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoDeleteRecord(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoDeleteRecord")
+func (s *Server) HandleAppBskyFeedGetPostThread(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetPostThread")
 	defer span.End()
 
-	var body comatprototypes.RepoDeleteRecord_Input
-	if err := c.Bind(&body); err != nil {
-		return err
+	var depth *int
+	if p := c.QueryParam("depth"); p != "" {
+		depth_val, err := strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+		depth = &depth_val
 	}
+	uri := c.QueryParam("uri")
+	var out *appbskytypes.FeedGetPostThread_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoDeleteRecord(ctx context.Context,body comatprototypes.RepoDeleteRecord_Input) error
-	handleErr = s.handleComAtprotoRepoDeleteRecord(ctx, &body)
+	// func (s *Server) handleAppBskyFeedGetPostThread(ctx context.Context,depth *int,uri string) (*appbskytypes.FeedGetPostThread_Output, error)
+	out, handleErr = s.handleAppBskyFeedGetPostThread(ctx, depth, uri)
 	if handleErr != nil {
 		return handleErr
 	}
-	return nil
+	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoDescribe(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoDescribe")
+func (s *Server) HandleAppBskyFeedGetRepostedBy(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetRepostedBy")
 	defer span.End()
-	user := c.QueryParam("user")
-	var out *comatprototypes.RepoDescribe_Output
+	before := c.QueryParam("before")
+	cid := c.QueryParam("cid")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	uri := c.QueryParam("uri")
+	var out *appbskytypes.FeedGetRepostedBy_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoDescribe(ctx context.Context,user string) (*comatprototypes.RepoDescribe_Output, error)
-	out, handleErr = s.handleComAtprotoRepoDescribe(ctx, user)
+	// func (s *Server) handleAppBskyFeedGetRepostedBy(ctx context.Context,before string,cid string,limit int,uri string) (*appbskytypes.FeedGetRepostedBy_Output, error)
+	out, handleErr = s.handleAppBskyFeedGetRepostedBy(ctx, before, cid, limit, uri)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoGetRecord(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoGetRecord")
+func (s *Server) HandleAppBskyFeedGetTimeline(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetTimeline")
 	defer span.End()
-	cid := c.QueryParam("cid")
-	collection := c.QueryParam("collection")
-	rkey := c.QueryParam("rkey")
-	user := c.QueryParam("user")
-	var out *comatprototypes.RepoGetRecord_Output
+	algorithm := c.QueryParam("algorithm")
+	before := c.QueryParam("before")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	var out *appbskytypes.FeedGetTimeline_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoGetRecord(ctx context.Context,cid string,collection string,rkey string,user string) (*comatprototypes.RepoGetRecord_Output, error)
-	out, handleErr = s.handleComAtprotoRepoGetRecord(ctx, cid, collection, rkey, user)
+	// func (s *Server) handleAppBskyFeedGetTimeline(ctx context.Context,algorithm string,before string,limit int) (*appbskytypes.FeedGetTimeline_Output, error)
+	out, handleErr = s.handleAppBskyFeedGetTimeline(ctx, algorithm, before, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoListRecords(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoListRecords")
+func (s *Server) HandleAppBskyFeedGetVotes(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetVotes")
 	defer span.End()
-	after := c.QueryParam("after")
 	before := c.QueryParam("before")
-	collection := c.QueryParam("collection")
+	cid := c.QueryParam("cid")
+	direction := c.QueryParam("direction")
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	var out *comatprototypes.RepoListRecords_Output
+	uri := c.QueryParam("uri")
+	var out *appbskytypes.FeedGetVotes_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoListRecords(ctx context.Context,after string,before string,collection string,limit int) (*comatprototypes.RepoListRecords_Output, error)
-	out, handleErr = s.handleComAtprotoRepoListRecords(ctx, after, before, collection, limit)
+	// func (s *Server) handleAppBskyFeedGetVotes(ctx context.Context,before string,cid string,direction string,limit int,uri string) (*appbskytypes.FeedGetVotes_Output, error)
+	out, handleErr = s.handleAppBskyFeedGetVotes(ctx, before, cid, direction, limit, uri)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoRepoPutRecord(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoPutRecord")
+func (s *Server) HandleAppBskyFeedSetVote(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedSetVote")
 	defer span.End()
 
-	var body comatprototypes.RepoPutRecord_Input
+	var body appbskytypes.FeedSetVote_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *comatprototypes.RepoPutRecord_Output
+	var out *appbskytypes.FeedSetVote_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoRepoPutRecord(ctx context.Context,body comatprototypes.RepoPutRecord_Input) (*comatprototypes.RepoPutRecord_Output, error)
-	out, handleErr = s.handleComAtprotoRepoPutRecord(ctx, &body)
+	// func (s *Server) handleAppBskyFeedSetVote(ctx context.Context,body appbskytypes.FeedSetVote_Input) (*appbskytypes.FeedSetVote_Output, error)
+	out, handleErr = s.handleAppBskyFeedSetVote(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoServerGetAccountsConfig(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoServerGetAccountsConfig")
+func (s *Server) HandleAppBskyGraphGetAssertions(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetAssertions")
 	defer span.End()
-	var out *comatprototypes.ServerGetAccountsConfig_Output
+	assertion := c.QueryParam("assertion")
+	author := c.QueryParam("author")
+	before := c.QueryParam("before")
+	var out *appbskytypes.GraphGetAssertions_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoServerGetAccountsConfig(ctx context.Context) (*comatprototypes.ServerGetAccountsConfig_Output, error)
-	out, handleErr = s.handleComAtprotoServerGetAccountsConfig(ctx)
+	// func (s *Server) handleAppBskyGraphGetAssertions(ctx context.Context,assertion string,author string,before string) (*appbskytypes.GraphGetAssertions_Output, error)
+	out, handleErr = s.handleAppBskyGraphGetAssertions(ctx, assertion, author, before)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSessionCreate(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionCreate")
+func (s *Server) HandleAppBskyGraphGetFollowers(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetFollowers")
 	defer span.End()
+	before := c.QueryParam("before")
 
-	var body comatprototypes.SessionCreate_Input
-	if err := c.Bind(&body); err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	var out *comatprototypes.SessionCreate_Output
+	user := c.QueryParam("user")
+	var out *appbskytypes.GraphGetFollowers_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSessionCreate(ctx context.Context,body comatprototypes.SessionCreate_Input) (*comatprototypes.SessionCreate_Output, error)
-	out, handleErr = s.handleComAtprotoSessionCreate(ctx, &body)
+	// func (s *Server) handleAppBskyGraphGetFollowers(ctx context.Context,before string,limit int,user string) (*appbskytypes.GraphGetFollowers_Output, error)
+	out, handleErr = s.handleAppBskyGraphGetFollowers(ctx, before, limit, user)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSessionDelete(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionDelete")
+func (s *Server) HandleAppBskyGraphGetFollows(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetFollows")
 	defer span.End()
+	before := c.QueryParam("before")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	user := c.QueryParam("user")
+	var out *appbskytypes.GraphGetFollows_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSessionDelete(ctx context.Context) error
-	handleErr = s.handleComAtprotoSessionDelete(ctx)
+	// func (s *Server) handleAppBskyGraphGetFollows(ctx context.Context,before string,limit int,user string) (*appbskytypes.GraphGetFollows_Output, error)
+	out, handleErr = s.handleAppBskyGraphGetFollows(ctx, before, limit, user)
 	if handleErr != nil {
 		return handleErr
 	}
-	return nil
+	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSessionGet(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionGet")
+func (s *Server) HandleAppBskyGraphGetMembers(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetMembers")
 	defer span.End()
-	var out *comatprototypes.SessionGet_Output
+	actor := c.QueryParam("actor")
+	before := c.QueryParam("before")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	var out *appbskytypes.GraphGetMembers_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSessionGet(ctx context.Context) (*comatprototypes.SessionGet_Output, error)
-	out, handleErr = s.handleComAtprotoSessionGet(ctx)
+	// func (s *Server) handleAppBskyGraphGetMembers(ctx context.Context,actor string,before string,limit int) (*appbskytypes.GraphGetMembers_Output, error)
+	out, handleErr = s.handleAppBskyGraphGetMembers(ctx, actor, before, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSessionRefresh(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionRefresh")
+func (s *Server) HandleAppBskyGraphGetMemberships(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetMemberships")
 	defer span.End()
-	var out *comatprototypes.SessionRefresh_Output
+	actor := c.QueryParam("actor")
+	before := c.QueryParam("before")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	var out *appbskytypes.GraphGetMemberships_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSessionRefresh(ctx context.Context) (*comatprototypes.SessionRefresh_Output, error)
-	out, handleErr = s.handleComAtprotoSessionRefresh(ctx)
+	// func (s *Server) handleAppBskyGraphGetMemberships(ctx context.Context,actor string,before string,limit int) (*appbskytypes.GraphGetMemberships_Output, error)
+	out, handleErr = s.handleAppBskyGraphGetMemberships(ctx, actor, before, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSyncGetRepo(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRepo")
+func (s *Server) HandleAppBskyNotificationGetCount(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationGetCount")
 	defer span.End()
-	did := c.QueryParam("did")
-	from := c.QueryParam("from")
-	var out io.Reader
+	var out *appbskytypes.NotificationGetCount_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSyncGetRepo(ctx context.Context,did string,from string) (io.Reader, error)
-	out, handleErr = s.handleComAtprotoSyncGetRepo(ctx, did, from)
+	// func (s *Server) handleAppBskyNotificationGetCount(ctx context.Context) (*appbskytypes.NotificationGetCount_Output, error)
+	out, handleErr = s.handleAppBskyNotificationGetCount(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSyncGetRoot(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRoot")
+func (s *Server) HandleAppBskyNotificationList(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationList")
 	defer span.End()
-	did := c.QueryParam("did")
-	var out *comatprototypes.SyncGetRoot_Output
+	before := c.QueryParam("before")
+
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
+	}
+	var out *appbskytypes.NotificationList_Output
 	var handleErr error
-	// func (s *Server) handleComAtprotoSyncGetRoot(ctx context.Context,did string) (*comatprototypes.SyncGetRoot_Output, error)
-	out, handleErr = s.handleComAtprotoSyncGetRoot(ctx, did)
+	// func (s *Server) handleAppBskyNotificationList(ctx context.Context,before string,limit int) (*appbskytypes.NotificationList_Output, error)
+	out, handleErr = s.handleAppBskyNotificationList(ctx, before, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleComAtprotoSyncUpdateRepo(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncUpdateRepo")
+func (s *Server) HandleAppBskyNotificationUpdateSeen(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationUpdateSeen")
 	defer span.End()
-	body := c.Request().Body
+
+	var body appbskytypes.NotificationUpdateSeen_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
 	var handleErr error
-	// func (s *Server) handleComAtprotoSyncUpdateRepo(ctx context.Context,r io.Reader) error
-	handleErr = s.handleComAtprotoSyncUpdateRepo(ctx, body)
+	// func (s *Server) handleAppBskyNotificationUpdateSeen(ctx context.Context,body appbskytypes.NotificationUpdateSeen_Input) error
+	handleErr = s.handleAppBskyNotificationUpdateSeen(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return nil
 }
 
-func (s *Server) RegisterHandlersAppBsky(e *echo.Echo) error {
-	e.POST("/xrpc/app.bsky.actor.createScene", s.HandleAppBskyActorCreateScene)
-	e.GET("/xrpc/app.bsky.actor.getProfile", s.HandleAppBskyActorGetProfile)
-	e.GET("/xrpc/app.bsky.actor.getSuggestions", s.HandleAppBskyActorGetSuggestions)
-	e.GET("/xrpc/app.bsky.actor.search", s.HandleAppBskyActorSearch)
-	e.GET("/xrpc/app.bsky.actor.searchTypeahead", s.HandleAppBskyActorSearchTypeahead)
-	e.POST("/xrpc/app.bsky.actor.updateProfile", s.HandleAppBskyActorUpdateProfile)
-	e.GET("/xrpc/app.bsky.feed.getAuthorFeed", s.HandleAppBskyFeedGetAuthorFeed)
-	e.GET("/xrpc/app.bsky.feed.getPostThread", s.HandleAppBskyFeedGetPostThread)
-	e.GET("/xrpc/app.bsky.feed.getRepostedBy", s.HandleAppBskyFeedGetRepostedBy)
-	e.GET("/xrpc/app.bsky.feed.getTimeline", s.HandleAppBskyFeedGetTimeline)
-	e.GET("/xrpc/app.bsky.feed.getVotes", s.HandleAppBskyFeedGetVotes)
-	e.POST("/xrpc/app.bsky.feed.setVote", s.HandleAppBskyFeedSetVote)
-	e.GET("/xrpc/app.bsky.graph.getAssertions", s.HandleAppBskyGraphGetAssertions)
-	e.GET("/xrpc/app.bsky.graph.getFollowers", s.HandleAppBskyGraphGetFollowers)
-	e.GET("/xrpc/app.bsky.graph.getFollows", s.HandleAppBskyGraphGetFollows)
-	e.GET("/xrpc/app.bsky.graph.getMembers", s.HandleAppBskyGraphGetMembers)
-	e.GET("/xrpc/app.bsky.graph.getMemberships", s.HandleAppBskyGraphGetMemberships)
-	e.GET("/xrpc/app.bsky.notification.getCount", s.HandleAppBskyNotificationGetCount)
-	e.GET("/xrpc/app.bsky.notification.list", s.HandleAppBskyNotificationList)
-	e.POST("/xrpc/app.bsky.notification.updateSeen", s.HandleAppBskyNotificationUpdateSeen)
+func (s *Server) RegisterHandlersComAtproto(e *echo.Echo) error {
+	e.POST("/xrpc/com.atproto.account.create", s.HandleComAtprotoAccountCreate)
+	e.POST("/xrpc/com.atproto.account.createInviteCode", s.HandleComAtprotoAccountCreateInviteCode)
+	e.POST("/xrpc/com.atproto.account.delete", s.HandleComAtprotoAccountDelete)
+	e.GET("/xrpc/com.atproto.account.get", s.HandleComAtprotoAccountGet)
+	e.POST("/xrpc/com.atproto.account.requestPasswordReset", s.HandleComAtprotoAccountRequestPasswordReset)
+	e.POST("/xrpc/com.atproto.account.resetPassword", s.HandleComAtprotoAccountResetPassword)
+	e.GET("/xrpc/com.atproto.handle.resolve", s.HandleComAtprotoHandleResolve)
+	e.POST("/xrpc/com.atproto.repo.batchWrite", s.HandleComAtprotoRepoBatchWrite)
+	e.POST("/xrpc/com.atproto.repo.createRecord", s.HandleComAtprotoRepoCreateRecord)
+	e.POST("/xrpc/com.atproto.repo.deleteRecord", s.HandleComAtprotoRepoDeleteRecord)
+	e.GET("/xrpc/com.atproto.repo.describe", s.HandleComAtprotoRepoDescribe)
+	e.GET("/xrpc/com.atproto.repo.getRecord", s.HandleComAtprotoRepoGetRecord)
+	e.GET("/xrpc/com.atproto.repo.listRecords", s.HandleComAtprotoRepoListRecords)
+	e.POST("/xrpc/com.atproto.repo.putRecord", s.HandleComAtprotoRepoPutRecord)
+	e.GET("/xrpc/com.atproto.server.getAccountsConfig", s.HandleComAtprotoServerGetAccountsConfig)
+	e.POST("/xrpc/com.atproto.session.create", s.HandleComAtprotoSessionCreate)
+	e.POST("/xrpc/com.atproto.session.delete", s.HandleComAtprotoSessionDelete)
+	e.GET("/xrpc/com.atproto.session.get", s.HandleComAtprotoSessionGet)
+	e.POST("/xrpc/com.atproto.session.refresh", s.HandleComAtprotoSessionRefresh)
+	e.GET("/xrpc/com.atproto.sync.getRepo", s.HandleComAtprotoSyncGetRepo)
+	e.GET("/xrpc/com.atproto.sync.getRoot", s.HandleComAtprotoSyncGetRoot)
+	e.POST("/xrpc/com.atproto.sync.updateRepo", s.HandleComAtprotoSyncUpdateRepo)
 	return nil
 }
 
-func (s *Server) HandleAppBskyActorCreateScene(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorCreateScene")
+func (s *Server) HandleComAtprotoAccountCreate(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountCreate")
 	defer span.End()
 
-	var body appbskytypes.ActorCreateScene_Input
+	var body comatprototypes.AccountCreate_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *appbskytypes.ActorCreateScene_Output
+	var out *comatprototypes.AccountCreate_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyActorCreateScene(ctx context.Context,body appbskytypes.ActorCreateScene_Input) (*appbskytypes.ActorCreateScene_Output, error)
-	out, handleErr = s.handleAppBskyActorCreateScene(ctx, &body)
+	// func (s *Server) handleComAtprotoAccountCreate(ctx context.Context,body comatprototypes.AccountCreate_Input) (*comatprototypes.AccountCreate_Output, error)
+	out, handleErr = s.handleComAtprotoAccountCreate(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyActorGetProfile(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorGetProfile")
+func (s *Server) HandleComAtprotoAccountCreateInviteCode(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountCreateInviteCode")
 	defer span.End()
-	actor := c.QueryParam("actor")
-	var out *appbskytypes.ActorGetProfile_Output
+
+	var body comatprototypes.AccountCreateInviteCode_Input
+	if err := c.Bind(&body); err != nil {
+		return err
+	}
+	var out *comatprototypes.AccountCreateInviteCode_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyActorGetProfile(ctx context.Context,actor string) (*appbskytypes.ActorGetProfile_Output, error)
-	out, handleErr = s.handleAppBskyActorGetProfile(ctx, actor)
+	// func (s *Server) handleComAtprotoAccountCreateInviteCode(ctx context.Context,body comatprototypes.AccountCreateInviteCode_Input) (*comatprototypes.AccountCreateInviteCode_Output, error)
+	out, handleErr = s.handleComAtprotoAccountCreateInviteCode(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyActorGetSuggestions(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorGetSuggestions")
+func (s *Server) HandleComAtprotoAccountDelete(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountDelete")
 	defer span.End()
-	cursor := c.QueryParam("cursor")
+	var handleErr error
+	// func (s *Server) handleComAtprotoAccountDelete(ctx context.Context) error
+	handleErr = s.handleComAtprotoAccountDelete(ctx)
+	if handleErr != nil {
+		return handleErr
+	}
+	return nil
+}
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	var out *appbskytypes.ActorGetSuggestions_Output
+func (s *Server) HandleComAtprotoAccountGet(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountGet")
+	defer span.End()
 	var handleErr error
-	// func (s *Server) handleAppBskyActorGetSuggestions(ctx context.Context,cursor string,limit int) (*appbskytypes.ActorGetSuggestions_Output, error)
-	out, handleErr = s.handleAppBskyActorGetSuggestions(ctx, cursor, limit)
+	// func (s *Server) handleComAtprotoAccountGet(ctx context.Context) error
+	handleErr = s.handleComAtprotoAccountGet(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
-	return c.JSON(200, out)
+	return nil
 }
 
-func (s *Server) HandleAppBskyActorSearch(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorSearch")
+func (s *Server) HandleComAtprotoAccountRequestPasswordReset(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountRequestPasswordReset")
 	defer span.End()
-	before := c.QueryParam("before")
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
+	var body comatprototypes.AccountRequestPasswordReset_Input
+	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	term := c.QueryParam("term")
-	var out *appbskytypes.ActorSearch_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyActorSearch(ctx context.Context,before string,limit int,term string) (*appbskytypes.ActorSearch_Output, error)
-	out, handleErr = s.handleAppBskyActorSearch(ctx, before, limit, term)
+	// func (s *Server) handleComAtprotoAccountRequestPasswordReset(ctx context.Context,body comatprototypes.AccountRequestPasswordReset_Input) error
+	handleErr = s.handleComAtprotoAccountRequestPasswordReset(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
-	return c.JSON(200, out)
+	return nil
 }
 
-func (s *Server) HandleAppBskyActorSearchTypeahead(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorSearchTypeahead")
+func (s *Server) HandleComAtprotoAccountResetPassword(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoAccountResetPassword")
 	defer span.End()
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
+	var body comatprototypes.AccountResetPassword_Input
+	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	term := c.QueryParam("term")
-	var out *appbskytypes.ActorSearchTypeahead_Output
+	var handleErr error
+	// func (s *Server) handleComAtprotoAccountResetPassword(ctx context.Context,body comatprototypes.AccountResetPassword_Input) error
+	handleErr = s.handleComAtprotoAccountResetPassword(ctx, &body)
+	if handleErr != nil {
+		return handleErr
+	}
+	return nil
+}
+
+func (s *Server) HandleComAtprotoHandleResolve(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoHandleResolve")
+	defer span.End()
+	handle := c.QueryParam("handle")
+	var out *comatprototypes.HandleResolve_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyActorSearchTypeahead(ctx context.Context,limit int,term string) (*appbskytypes.ActorSearchTypeahead_Output, error)
-	out, handleErr = s.handleAppBskyActorSearchTypeahead(ctx, limit, term)
+	// func (s *Server) handleComAtprotoHandleResolve(ctx context.Context,handle string) (*comatprototypes.HandleResolve_Output, error)
+	out, handleErr = s.handleComAtprotoHandleResolve(ctx, handle)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyActorUpdateProfile(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyActorUpdateProfile")
+func (s *Server) HandleComAtprotoRepoBatchWrite(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoBatchWrite")
 	defer span.End()
 
-	var body appbskytypes.ActorUpdateProfile_Input
+	var body comatprototypes.RepoBatchWrite_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *appbskytypes.ActorUpdateProfile_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyActorUpdateProfile(ctx context.Context,body appbskytypes.ActorUpdateProfile_Input) (*appbskytypes.ActorUpdateProfile_Output, error)
-	out, handleErr = s.handleAppBskyActorUpdateProfile(ctx, &body)
+	// func (s *Server) handleComAtprotoRepoBatchWrite(ctx context.Context,body comatprototypes.RepoBatchWrite_Input) error
+	handleErr = s.handleComAtprotoRepoBatchWrite(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
-	return c.JSON(200, out)
+	return nil
 }
 
-func (s *Server) HandleAppBskyFeedGetAuthorFeed(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetAuthorFeed")
+func (s *Server) HandleComAtprotoRepoCreateRecord(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoCreateRecord")
 	defer span.End()
-	author := c.QueryParam("author")
-	before := c.QueryParam("before")
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
+	var body comatprototypes.RepoCreateRecord_Input
+	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *appbskytypes.FeedGetAuthorFeed_Output
+	var out *comatprototypes.RepoCreateRecord_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedGetAuthorFeed(ctx context.Context,author string,before string,limit int) (*appbskytypes.FeedGetAuthorFeed_Output, error)
-	out, handleErr = s.handleAppBskyFeedGetAuthorFeed(ctx, author, before, limit)
+	// func (s *Server) handleComAtprotoRepoCreateRecord(ctx context.Context,body comatprototypes.RepoCreateRecord_Input) (*comatprototypes.RepoCreateRecord_Output, error)
+	out, handleErr = s.handleComAtprotoRepoCreateRecord(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyFeedGetPostThread(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetPostThread")
+func (s *Server) HandleComAtprotoRepoDeleteRecord(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoDeleteRecord")
 	defer span.End()
 
-	depth, err := strconv.Atoi(c.QueryParam("depth"))
-	if err != nil {
+	var body comatprototypes.RepoDeleteRecord_Input
+	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	uri := c.QueryParam("uri")
-	var out *appbskytypes.FeedGetPostThread_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedGetPostThread(ctx context.Context,depth int,uri string) (*appbskytypes.FeedGetPostThread_Output, error)
-	out, handleErr = s.handleAppBskyFeedGetPostThread(ctx, depth, uri)
+	// func (s *Server) handleComAtprotoRepoDeleteRecord(ctx context.Context,body comatprototypes.RepoDeleteRecord_Input) error
+	handleErr = s.handleComAtprotoRepoDeleteRecord(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
-	return c.JSON(200, out)
+	return nil
 }
 
-func (s *Server) HandleAppBskyFeedGetRepostedBy(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetRepostedBy")
+func (s *Server) HandleComAtprotoRepoDescribe(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoDescribe")
 	defer span.End()
-	before := c.QueryParam("before")
-	cid := c.QueryParam("cid")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	uri := c.QueryParam("uri")
-	var out *appbskytypes.FeedGetRepostedBy_Output
+	user := c.QueryParam("user")
+	var out *comatprototypes.RepoDescribe_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedGetRepostedBy(ctx context.Context,before string,cid string,limit int,uri string) (*appbskytypes.FeedGetRepostedBy_Output, error)
-	out, handleErr = s.handleAppBskyFeedGetRepostedBy(ctx, before, cid, limit, uri)
+	// func (s *Server) handleComAtprotoRepoDescribe(ctx context.Context,user string) (*comatprototypes.RepoDescribe_Output, error)
+	out, handleErr = s.handleComAtprotoRepoDescribe(ctx, user)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyFeedGetTimeline(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetTimeline")
+func (s *Server) HandleComAtprotoRepoGetRecord(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoGetRecord")
 	defer span.End()
-	algorithm := c.QueryParam("algorithm")
-	before := c.QueryParam("before")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	var out *appbskytypes.FeedGetTimeline_Output
+	cid := c.QueryParam("cid")
+	collection := c.QueryParam("collection")
+	rkey := c.QueryParam("rkey")
+	user := c.QueryParam("user")
+	var out *comatprototypes.RepoGetRecord_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedGetTimeline(ctx context.Context,algorithm string,before string,limit int) (*appbskytypes.FeedGetTimeline_Output, error)
-	out, handleErr = s.handleAppBskyFeedGetTimeline(ctx, algorithm, before, limit)
+	// func (s *Server) handleComAtprotoRepoGetRecord(ctx context.Context,cid string,collection string,rkey string,user string) (*comatprototypes.RepoGetRecord_Output, error)
+	out, handleErr = s.handleComAtprotoRepoGetRecord(ctx, cid, collection, rkey, user)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyFeedGetVotes(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedGetVotes")
+func (s *Server) HandleComAtprotoRepoListRecords(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoListRecords")
 	defer span.End()
+	after := c.QueryParam("after")
 	before := c.QueryParam("before")
-	cid := c.QueryParam("cid")
-	direction := c.QueryParam("direction")
+	collection := c.QueryParam("collection")
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
+	var limit int
+	if p := c.QueryParam("limit"); p != "" {
+		var err error
+		limit, err = strconv.Atoi(p)
+		if err != nil {
+			return err
+		}
+	} else {
+		limit = 50
 	}
-	uri := c.QueryParam("uri")
-	var out *appbskytypes.FeedGetVotes_Output
+	var out *comatprototypes.RepoListRecords_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedGetVotes(ctx context.Context,before string,cid string,direction string,limit int,uri string) (*appbskytypes.FeedGetVotes_Output, error)
-	out, handleErr = s.handleAppBskyFeedGetVotes(ctx, before, cid, direction, limit, uri)
+	// func (s *Server) handleComAtprotoRepoListRecords(ctx context.Context,after string,before string,collection string,limit int) (*comatprototypes.RepoListRecords_Output, error)
+	out, handleErr = s.handleComAtprotoRepoListRecords(ctx, after, before, collection, limit)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyFeedSetVote(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyFeedSetVote")
+func (s *Server) HandleComAtprotoRepoPutRecord(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoRepoPutRecord")
 	defer span.End()
 
-	var body appbskytypes.FeedSetVote_Input
+	var body comatprototypes.RepoPutRecord_Input
 	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	var out *appbskytypes.FeedSetVote_Output
+	var out *comatprototypes.RepoPutRecord_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyFeedSetVote(ctx context.Context,body appbskytypes.FeedSetVote_Input) (*appbskytypes.FeedSetVote_Output, error)
-	out, handleErr = s.handleAppBskyFeedSetVote(ctx, &body)
+	// func (s *Server) handleComAtprotoRepoPutRecord(ctx context.Context,body comatprototypes.RepoPutRecord_Input) (*comatprototypes.RepoPutRecord_Output, error)
+	out, handleErr = s.handleComAtprotoRepoPutRecord(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyGraphGetAssertions(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetAssertions")
+func (s *Server) HandleComAtprotoServerGetAccountsConfig(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoServerGetAccountsConfig")
 	defer span.End()
-	assertion := c.QueryParam("assertion")
-	author := c.QueryParam("author")
-	before := c.QueryParam("before")
-	var out *appbskytypes.GraphGetAssertions_Output
+	var out *comatprototypes.ServerGetAccountsConfig_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyGraphGetAssertions(ctx context.Context,assertion string,author string,before string) (*appbskytypes.GraphGetAssertions_Output, error)
-	out, handleErr = s.handleAppBskyGraphGetAssertions(ctx, assertion, author, before)
+	// func (s *Server) handleComAtprotoServerGetAccountsConfig(ctx context.Context) (*comatprototypes.ServerGetAccountsConfig_Output, error)
+	out, handleErr = s.handleComAtprotoServerGetAccountsConfig(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyGraphGetFollowers(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetFollowers")
+func (s *Server) HandleComAtprotoSessionCreate(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionCreate")
 	defer span.End()
-	before := c.QueryParam("before")
 
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
+	var body comatprototypes.SessionCreate_Input
+	if err := c.Bind(&body); err != nil {
 		return err
 	}
-	user := c.QueryParam("user")
-	var out *appbskytypes.GraphGetFollowers_Output
+	var out *comatprototypes.SessionCreate_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyGraphGetFollowers(ctx context.Context,before string,limit int,user string) (*appbskytypes.GraphGetFollowers_Output, error)
-	out, handleErr = s.handleAppBskyGraphGetFollowers(ctx, before, limit, user)
+	// func (s *Server) handleComAtprotoSessionCreate(ctx context.Context,body comatprototypes.SessionCreate_Input) (*comatprototypes.SessionCreate_Output, error)
+	out, handleErr = s.handleComAtprotoSessionCreate(ctx, &body)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyGraphGetFollows(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetFollows")
+func (s *Server) HandleComAtprotoSessionDelete(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionDelete")
 	defer span.End()
-	before := c.QueryParam("before")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	user := c.QueryParam("user")
-	var out *appbskytypes.GraphGetFollows_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyGraphGetFollows(ctx context.Context,before string,limit int,user string) (*appbskytypes.GraphGetFollows_Output, error)
-	out, handleErr = s.handleAppBskyGraphGetFollows(ctx, before, limit, user)
+	// func (s *Server) handleComAtprotoSessionDelete(ctx context.Context) error
+	handleErr = s.handleComAtprotoSessionDelete(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
-	return c.JSON(200, out)
+	return nil
 }
 
-func (s *Server) HandleAppBskyGraphGetMembers(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetMembers")
+func (s *Server) HandleComAtprotoSessionGet(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionGet")
 	defer span.End()
-	actor := c.QueryParam("actor")
-	before := c.QueryParam("before")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	var out *appbskytypes.GraphGetMembers_Output
+	var out *comatprototypes.SessionGet_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyGraphGetMembers(ctx context.Context,actor string,before string,limit int) (*appbskytypes.GraphGetMembers_Output, error)
-	out, handleErr = s.handleAppBskyGraphGetMembers(ctx, actor, before, limit)
+	// func (s *Server) handleComAtprotoSessionGet(ctx context.Context) (*comatprototypes.SessionGet_Output, error)
+	out, handleErr = s.handleComAtprotoSessionGet(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyGraphGetMemberships(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyGraphGetMemberships")
+func (s *Server) HandleComAtprotoSessionRefresh(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSessionRefresh")
 	defer span.End()
-	actor := c.QueryParam("actor")
-	before := c.QueryParam("before")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	var out *appbskytypes.GraphGetMemberships_Output
+	var out *comatprototypes.SessionRefresh_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyGraphGetMemberships(ctx context.Context,actor string,before string,limit int) (*appbskytypes.GraphGetMemberships_Output, error)
-	out, handleErr = s.handleAppBskyGraphGetMemberships(ctx, actor, before, limit)
+	// func (s *Server) handleComAtprotoSessionRefresh(ctx context.Context) (*comatprototypes.SessionRefresh_Output, error)
+	out, handleErr = s.handleComAtprotoSessionRefresh(ctx)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyNotificationGetCount(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationGetCount")
+func (s *Server) HandleComAtprotoSyncGetRepo(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRepo")
 	defer span.End()
-	var out *appbskytypes.NotificationGetCount_Output
+	did := c.QueryParam("did")
+	from := c.QueryParam("from")
+	var out io.Reader
 	var handleErr error
-	// func (s *Server) handleAppBskyNotificationGetCount(ctx context.Context) (*appbskytypes.NotificationGetCount_Output, error)
-	out, handleErr = s.handleAppBskyNotificationGetCount(ctx)
+	// func (s *Server) handleComAtprotoSyncGetRepo(ctx context.Context,did string,from string) (io.Reader, error)
+	out, handleErr = s.handleComAtprotoSyncGetRepo(ctx, did, from)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyNotificationList(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationList")
+func (s *Server) HandleComAtprotoSyncGetRoot(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncGetRoot")
 	defer span.End()
-	before := c.QueryParam("before")
-
-	limit, err := strconv.Atoi(c.QueryParam("limit"))
-	if err != nil {
-		return err
-	}
-	var out *appbskytypes.NotificationList_Output
+	did := c.QueryParam("did")
+	var out *comatprototypes.SyncGetRoot_Output
 	var handleErr error
-	// func (s *Server) handleAppBskyNotificationList(ctx context.Context,before string,limit int) (*appbskytypes.NotificationList_Output, error)
-	out, handleErr = s.handleAppBskyNotificationList(ctx, before, limit)
+	// func (s *Server) handleComAtprotoSyncGetRoot(ctx context.Context,did string) (*comatprototypes.SyncGetRoot_Output, error)
+	out, handleErr = s.handleComAtprotoSyncGetRoot(ctx, did)
 	if handleErr != nil {
 		return handleErr
 	}
 	return c.JSON(200, out)
 }
 
-func (s *Server) HandleAppBskyNotificationUpdateSeen(c echo.Context) error {
-	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleAppBskyNotificationUpdateSeen")
+func (s *Server) HandleComAtprotoSyncUpdateRepo(c echo.Context) error {
+	ctx, span := otel.Tracer("server").Start(c.Request().Context(), "HandleComAtprotoSyncUpdateRepo")
 	defer span.End()
-
-	var body appbskytypes.NotificationUpdateSeen_Input
-	if err := c.Bind(&body); err != nil {
-		return err
-	}
+	body := c.Request().Body
 	var handleErr error
-	// func (s *Server) handleAppBskyNotificationUpdateSeen(ctx context.Context,body appbskytypes.NotificationUpdateSeen_Input) error
-	handleErr = s.handleAppBskyNotificationUpdateSeen(ctx, &body)
+	// func (s *Server) handleComAtprotoSyncUpdateRepo(ctx context.Context,r io.Reader) error
+	handleErr = s.handleComAtprotoSyncUpdateRepo(ctx, body)
 	if handleErr != nil {
 		return handleErr
 	}

docs/auth.md

···
+# Auth
+
+The auth system uses two tokens, an access token and a refresh token.
+
+The access token is a jwt with the following values:
+```
+scope: "com.atproto.access"
+sub: <the users DID>
+iat: the current time, in unix epoch seconds
+exp: the expiry date, usually around an hour, but at least 15 minutes
+```
+
+The refresh token is a jwt with the following values:
+```
+scope: "com.atproto.refresh"
+sub: <the users DID>
+iat: the current time, in unix epoch seconds
+exp: the expiry date, usually around a week, must be significantly longer than the access token
+jti: a unique identifier for this token
+```
+
+The access token is what is used for all requests, however since it expires
+quickly, it must be refreshed periodically using the refresh token.
+When the refresh token is used, it must be marked as deleted, and the new token then replaces it.
+Note: The old access token is not necessarily disabled at that point of refreshing.
+

lex/gen.go

···
 	Const      any                    `json:"const"`
 	Enum       []string               `json:"enum"`
 	Closed     bool                   `json:"closed"`
+
+	Default any `json:"default"`
+	Minimum any `json:"minimum"`
+	Maximum any `json:"maximum"`
 }
 
 func (s *Schema) Name() string {
···
 
 		if t.Type.record && !strings.Contains(t.Name, "_") {
 			id := t.Type.id
-			if t.Type.defName != ""  {
-			id = id + "#" + t.Type.defName
-		}
+			if t.Type.defName != "" {
+				id = id + "#" + t.Type.defName
+			}
 			fmt.Fprintf(w, "util.RegisterType(%q, %s{})\n", id, t.Name)
 		}
 	}
···
 func (s *TypeSchema) WriteHandlerStub(w io.Writer, fname, shortname, impname string) error {
 	paramtypes := []string{"ctx context.Context"}
 	if s.Type == "query" {
+
 		if s.Parameters != nil {
+			var required map[string]bool
+			if s.Parameters.Required != nil {
+				required = make(map[string]bool)
+				for _, r := range s.Required {
+					required[r] = true
+				}
+			}
 			orderedMapIter[TypeSchema](s.Parameters.Properties, func(k string, t TypeSchema) error {
 				switch t.Type {
 				case "string":
 					paramtypes = append(paramtypes, k+" string")
 				case "integer":
-					paramtypes = append(paramtypes, k+" int")
+					if required != nil && !required[k] {
+						paramtypes = append(paramtypes, k+" *int")
+					} else {
+						paramtypes = append(paramtypes, k+" int")
+					}
 				case "number":
 					return fmt.Errorf("non-integer numbers currently unsupported")
 				default:
···
 	fmt.Fprintf(w, "ctx, span := otel.Tracer(\"server\").Start(c.Request().Context(), %q)\n", "Handle"+fname)
 	fmt.Fprintf(w, "defer span.End()\n")
 
-	var required map[string]bool
-	if s.Required != nil {
-		for _, r := range s.Required {
-			required[r] = true
-		}
-	}
-
 	paramtypes := []string{"ctx context.Context"}
 	params := []string{"ctx"}
 	if s.Type == "query" {
 		if s.Parameters != nil {
+			required := make(map[string]bool)
+			for _, r := range s.Parameters.Required {
+					required[r] = true
+			}
+			for k, v := range s.Parameters.Properties {
+				if v.Default != nil {
+					required[k] = true
+				}
+			}
 			orderedMapIter[TypeSchema](s.Parameters.Properties, func(k string, t TypeSchema) error {
 				switch t.Type {
 				case "string":
···
 				case "integer":
 					params = append(params, k)
 
-					if required != nil && !required[k] {
-					paramtypes = append(paramtypes, k+" *int")
-					fmt.Fprintf(w, `
+					if !required[k] {
+						paramtypes = append(paramtypes, k+" *int")
+						fmt.Fprintf(w, `
 var %s *int
 if p := c.QueryParam("%s"); p != "" {
-%s_val, err := strconv.Atoi(p)
+	%s_val, err := strconv.Atoi(p)
+	if err != nil {
+		return err
+	}
+	%s  = &%s_val
+}
+`, k, k, k, k, k)
+					} else if t.Default != nil {
+						paramtypes = append(paramtypes, k+" int")
+						fmt.Fprintf(w, `
+var %s int
+if p := c.QueryParam("%s"); p != "" {
+var err error
+%s, err = strconv.Atoi(p)
 if err != nil {
 	return err
 }
-	%s  = &%s_val
+} else {
+	%s = %d
 }
-`, k, k, k, k, k)
+`, k, k,k, k, int(t.Default.(float64)))
 					} else {
-					paramtypes = append(paramtypes, k+" int")
-					fmt.Fprintf(w, `
+
+						paramtypes = append(paramtypes, k+" int")
+						fmt.Fprintf(w, `
 %s, err := strconv.Atoi(c.QueryParam("%s"))
 if err != nil {
 	return err
 }
 `, k, k)
 					}
-
 
 				case "number":
 					return fmt.Errorf("non-integer numbers currently unsupported")
···
 			fmt.Fprintf(w, "\tLexiconTypeID string `json:\"$type\" cborgen:\"$type,const=%s\"`\n", ts.id)
 		}
 
-		var required map[string]bool 
-		if ts.Required != nil {
-		required = make(map[string]bool)
+		required := make(map[string]bool)
 		for _, req := range ts.Required {
 			required[req] = true
 		}
-	}
 
 		for k, v := range ts.Properties {
 			goname := strings.Title(k)
···
 			}
 
 			var ptr string
-			if required != nil && !required[k] {
+			if !required[k] {
 				if !strings.HasPrefix(tname, "*") && !strings.HasPrefix(tname, "[]") {
 					ptr = "*"
 				}

lex/util/cbor_gen.go

···
+// Code generated by github.com/whyrusleeping/cbor-gen. DO NOT EDIT.
+
+package util
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"sort"
+
+	cid "github.com/ipfs/go-cid"
+	cbg "github.com/whyrusleeping/cbor-gen"
+	xerrors "golang.org/x/xerrors"
+)
+
+var _ = xerrors.Errorf
+var _ = cid.Undef
+var _ = math.E
+var _ = sort.Sort
+
+func (t *CborChecker) MarshalCBOR(w io.Writer) error {
+	if t == nil {
+		_, err := w.Write(cbg.CborNull)
+		return err
+	}
+
+	cw := cbg.NewCborWriter(w)
+
+	if _, err := cw.Write([]byte{161}); err != nil {
+		return err
+	}
+
+	// t.Type (string) (string)
+	if len("$type") > cbg.MaxLength {
+		return xerrors.Errorf("Value in field \"$type\" was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string("$type")); err != nil {
+		return err
+	}
+
+	if len(t.Type) > cbg.MaxLength {
+		return xerrors.Errorf("Value in field t.Type was too long")
+	}
+
+	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil {
+		return err
+	}
+	if _, err := io.WriteString(w, string(t.Type)); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *CborChecker) UnmarshalCBOR(r io.Reader) (err error) {
+	*t = CborChecker{}
+
+	cr := cbg.NewCborReader(r)
+
+	maj, extra, err := cr.ReadHeader()
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if err == io.EOF {
+			err = io.ErrUnexpectedEOF
+		}
+	}()
+
+	if maj != cbg.MajMap {
+		return fmt.Errorf("cbor input should be of type map")
+	}
+
+	if extra > cbg.MaxLength {
+		return fmt.Errorf("CborChecker: map struct too large (%d)", extra)
+	}
+
+	var name string
+	n := extra
+
+	for i := uint64(0); i < n; i++ {
+
+		{
+			sval, err := cbg.ReadString(cr)
+			if err != nil {
+				return err
+			}
+
+			name = string(sval)
+		}
+
+		switch name {
+		// t.Type (string) (string)
+		case "$type":
+
+			{
+				sval, err := cbg.ReadString(cr)
+				if err != nil {
+					return err
+				}
+
+				t.Type = string(sval)
+			}
+
+		default:
+			// Field doesn't exist on this type, so ignore it
+			cbg.ScanForLinks(r, func(cid.Cid) {})
+		}
+	}
+
+	return nil
+}

lex/util/decoder.go

···
+package util
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	cbg "github.com/whyrusleeping/cbor-gen"
+)
+
+var lexTypesMap map[string]reflect.Type
+
+func init() {
+	lexTypesMap = make(map[string]reflect.Type)
+}
+
+func RegisterType(id string, val any) {
+	t := reflect.TypeOf(val)
+
+	if t.Kind() == reflect.Pointer {
+		t = t.Elem()
+	}
+
+	if _, ok := lexTypesMap[id]; ok {
+		panic(fmt.Sprintf("already registered type for %q", id))
+	}
+
+	lexTypesMap[id] = t
+}
+
+func JsonDecodeValue(b []byte) (any, error) {
+	tstr, err := TypeExtract(b)
+	if err != nil {
+		return nil, err
+	}
+
+	t, ok := lexTypesMap[tstr]
+	if !ok {
+		return nil, fmt.Errorf("unrecognized type: %q", tstr)
+	}
+
+	val := reflect.New(t)
+
+	ival := val.Interface()
+	if err := json.Unmarshal(b, ival); err != nil {
+		return nil, err
+	}
+
+	return ival, nil
+}
+
+func CborDecodeValue(b []byte) (any, error) {
+	tstr, err := CborTypeExtract(b)
+	if err != nil {
+		return nil, err
+	}
+
+	t, ok := lexTypesMap[tstr]
+	if !ok {
+		return nil, fmt.Errorf("unrecognized type: %q", tstr)
+	}
+
+	val := reflect.New(t)
+
+	ival, ok := val.Interface().(cbg.CBORUnmarshaler)
+	if !ok {
+		return nil, fmt.Errorf("registered type did not have proper cbor hooks")
+	}
+
+	if err := ival.UnmarshalCBOR(bytes.NewReader(b)); err != nil {
+		return nil, err
+	}
+
+	fmt.Printf("DECODED VALUE: %#v\n", ival)
+
+	return ival, nil
+}

repo/repo.go

···
 	return r.bs
 }
 
-func (r *Repo) CreateRecord(ctx context.Context, nsid string, rec CborMarshaler) (cid.Cid, error) {
+func (r *Repo) CreateRecord(ctx context.Context, nsid string, rec CborMarshaler) (cid.Cid, string, error) {
 	r.dirty = true
 	t, err := r.getMst(ctx)
 	if err != nil {
-		return cid.Undef, fmt.Errorf("failed to get mst: %w", err)
+		return cid.Undef, "", fmt.Errorf("failed to get mst: %w", err)
 	}
 
 	k, err := r.cst.Put(ctx, rec)
 	if err != nil {
-		return cid.Undef, err
+		return cid.Undef, "", err
 	}
 
-	nmst, err := t.Add(ctx, nsid+"/"+NextTID(), k, -1)
+	tid := NextTID()
+
+	nmst, err := t.Add(ctx, nsid+"/"+tid, k, -1)
 	if err != nil {
-		return cid.Undef, fmt.Errorf("mst.Add failed: %w", err)
+		return cid.Undef, "", fmt.Errorf("mst.Add failed: %w", err)
 	}
 
 	r.mst = nmst
-	return k, nil
+	return k, tid, nil
 }
 
 func (r *Repo) Commit(ctx context.Context) (cid.Cid, error) {

repomgr/repomgr.go

···
 }
 
 func (rm *RepoManager) CreateRecord(ctx context.Context, user uint, collection string, rec cbg.CBORMarshaler) (string, cid.Cid, error) {
-	ntid := repo.NextTID()
-	rkey := collection + "/" + ntid
 
 	unlock := rm.lockUser(user)
 	defer unlock()
···
 		return "", cid.Undef, err
 	}
 
-	cc, err := r.CreateRecord(ctx, rkey, rec)
+	cc, tid, err := r.CreateRecord(ctx, collection, rec)
 	if err != nil {
 		return "", cid.Undef, err
 	}
···
 			OldRoot:    head,
 			NewRoot:    nroot,
 			Collection: collection,
-			Rkey:       rkey,
+			Rkey:       tid,
 			Record:     rec,
 			RecCid:     cc,
 		})
 	}
 
-	return rkey, cc, nil
+	return collection + "/" + tid, cc, nil
 }
 
 func (rm *RepoManager) InitNewActor(ctx context.Context, user uint, handle, did, displayname string, declcid, actortype string) error {