feat: Add XRPC procedures for all actions

- Implemented deleteGallery, deleteItem, and updateGallery endpoints for gallery management.
- Added createFollow and deleteFollow endpoints for managing follow relationships.
- Introduced photo handling APIs including uploadPhoto, deletePhoto, createExif, and applyAlts.
- Created lexicons for gallery and photo operations to define input/output schemas.
- Enhanced graph functionality with methods to retrieve followers and following with profiles.
- Added favorite creation and deletion functionalities with corresponding lexicons.

__generated__/index.ts

···
 import { schemas } from './lexicons.ts'
 import * as SocialGrainNotificationUpdateSeen from './types/social/grain/notification/updateSeen.ts'
 import * as SocialGrainNotificationGetNotifications from './types/social/grain/notification/getNotifications.ts'
+import * as SocialGrainCommentDeleteComment from './types/social/grain/comment/deleteComment.ts'
+import * as SocialGrainCommentCreateComment from './types/social/grain/comment/createComment.ts'
+import * as SocialGrainGalleryDeleteGallery from './types/social/grain/gallery/deleteGallery.ts'
+import * as SocialGrainGalleryCreateItem from './types/social/grain/gallery/createItem.ts'
+import * as SocialGrainGalleryCreateGallery from './types/social/grain/gallery/createGallery.ts'
+import * as SocialGrainGalleryDeleteItem from './types/social/grain/gallery/deleteItem.ts'
+import * as SocialGrainGalleryUpdateGallery from './types/social/grain/gallery/updateGallery.ts'
+import * as SocialGrainGalleryApplySort from './types/social/grain/gallery/applySort.ts'
 import * as SocialGrainGalleryGetGalleryThread from './types/social/grain/gallery/getGalleryThread.ts'
 import * as SocialGrainGalleryGetActorGalleries from './types/social/grain/gallery/getActorGalleries.ts'
 import * as SocialGrainGalleryGetGallery from './types/social/grain/gallery/getGallery.ts'
+import * as SocialGrainGraphDeleteFollow from './types/social/grain/graph/deleteFollow.ts'
+import * as SocialGrainGraphCreateFollow from './types/social/grain/graph/createFollow.ts'
 import * as SocialGrainGraphGetFollowers from './types/social/grain/graph/getFollowers.ts'
 import * as SocialGrainGraphGetFollows from './types/social/grain/graph/getFollows.ts'
+import * as SocialGrainFavoriteDeleteFavorite from './types/social/grain/favorite/deleteFavorite.ts'
+import * as SocialGrainFavoriteCreateFavorite from './types/social/grain/favorite/createFavorite.ts'
 import * as SocialGrainFeedGetTimeline from './types/social/grain/feed/getTimeline.ts'
 import * as SocialGrainActorGetProfile from './types/social/grain/actor/getProfile.ts'
 import * as SocialGrainActorSearchActors from './types/social/grain/actor/searchActors.ts'
+import * as SocialGrainActorUpdateAvatar from './types/social/grain/actor/updateAvatar.ts'
 import * as SocialGrainActorGetActorFavs from './types/social/grain/actor/getActorFavs.ts'
+import * as SocialGrainActorUpdateProfile from './types/social/grain/actor/updateProfile.ts'
+import * as SocialGrainPhotoDeletePhoto from './types/social/grain/photo/deletePhoto.ts'
+import * as SocialGrainPhotoUploadPhoto from './types/social/grain/photo/uploadPhoto.ts'
+import * as SocialGrainPhotoCreateExif from './types/social/grain/photo/createExif.ts'
+import * as SocialGrainPhotoApplyAlts from './types/social/grain/photo/applyAlts.ts'
 import * as SocialGrainPhotoGetActorPhotos from './types/social/grain/photo/getActorPhotos.ts'
 
 export const APP_BSKY_GRAPH = {
···
 export class SocialGrainNS {
   _server: Server
   notification: SocialGrainNotificationNS
+  comment: SocialGrainCommentNS
   gallery: SocialGrainGalleryNS
   graph: SocialGrainGraphNS
+  favorite: SocialGrainFavoriteNS
   labeler: SocialGrainLabelerNS
   feed: SocialGrainFeedNS
   actor: SocialGrainActorNS
···
   constructor(server: Server) {
     this._server = server
     this.notification = new SocialGrainNotificationNS(server)
+    this.comment = new SocialGrainCommentNS(server)
     this.gallery = new SocialGrainGalleryNS(server)
     this.graph = new SocialGrainGraphNS(server)
+    this.favorite = new SocialGrainFavoriteNS(server)
     this.labeler = new SocialGrainLabelerNS(server)
     this.feed = new SocialGrainFeedNS(server)
     this.actor = new SocialGrainActorNS(server)
···
   }
 }
 
+export class SocialGrainCommentNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  deleteComment<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainCommentDeleteComment.Handler<ExtractAuth<AV>>,
+      SocialGrainCommentDeleteComment.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.comment.deleteComment' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createComment<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainCommentCreateComment.Handler<ExtractAuth<AV>>,
+      SocialGrainCommentCreateComment.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.comment.createComment' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
 export class SocialGrainGalleryNS {
   _server: Server
 
   constructor(server: Server) {
     this._server = server
+  }
+
+  deleteGallery<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryDeleteGallery.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryDeleteGallery.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.deleteGallery' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createItem<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryCreateItem.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryCreateItem.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.createItem' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createGallery<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryCreateGallery.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryCreateGallery.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.createGallery' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  deleteItem<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryDeleteItem.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryDeleteItem.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.deleteItem' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  updateGallery<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryUpdateGallery.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryUpdateGallery.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.updateGallery' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  applySort<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryApplySort.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryApplySort.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.applySort' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
   }
 
   getGalleryThread<AV extends AuthVerifier>(
···
     this._server = server
   }
 
+  deleteFollow<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGraphDeleteFollow.Handler<ExtractAuth<AV>>,
+      SocialGrainGraphDeleteFollow.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.graph.deleteFollow' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createFollow<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGraphCreateFollow.Handler<ExtractAuth<AV>>,
+      SocialGrainGraphCreateFollow.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.graph.createFollow' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getFollowers<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
···
   }
 }
 
+export class SocialGrainFavoriteNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  deleteFavorite<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainFavoriteDeleteFavorite.Handler<ExtractAuth<AV>>,
+      SocialGrainFavoriteDeleteFavorite.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.favorite.deleteFavorite' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createFavorite<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainFavoriteCreateFavorite.Handler<ExtractAuth<AV>>,
+      SocialGrainFavoriteCreateFavorite.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.favorite.createFavorite' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
 export class SocialGrainLabelerNS {
   _server: Server
 
···
     return this._server.xrpc.method(nsid, cfg)
   }
 
+  updateAvatar<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainActorUpdateAvatar.Handler<ExtractAuth<AV>>,
+      SocialGrainActorUpdateAvatar.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.actor.updateAvatar' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
   getActorFavs<AV extends AuthVerifier>(
     cfg: ConfigOf<
       AV,
···
     >,
   ) {
     const nsid = 'social.grain.actor.getActorFavs' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  updateProfile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainActorUpdateProfile.Handler<ExtractAuth<AV>>,
+      SocialGrainActorUpdateProfile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.actor.updateProfile' // @ts-ignore
     return this._server.xrpc.method(nsid, cfg)
   }
 }
···
 
   constructor(server: Server) {
     this._server = server
+  }
+
+  deletePhoto<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainPhotoDeletePhoto.Handler<ExtractAuth<AV>>,
+      SocialGrainPhotoDeletePhoto.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.photo.deletePhoto' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  uploadPhoto<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainPhotoUploadPhoto.Handler<ExtractAuth<AV>>,
+      SocialGrainPhotoUploadPhoto.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.photo.uploadPhoto' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createExif<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainPhotoCreateExif.Handler<ExtractAuth<AV>>,
+      SocialGrainPhotoCreateExif.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.photo.createExif' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  applyAlts<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainPhotoApplyAlts.Handler<ExtractAuth<AV>>,
+      SocialGrainPhotoApplyAlts.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.photo.applyAlts' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
   }
 
   getActorPhotos<AV extends AuthVerifier>(

__generated__/lexicons.ts

···
       },
     },
   },
+  SocialGrainCommentDeleteComment: {
+    lexicon: 1,
+    id: 'social.grain.comment.deleteComment',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a comment. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the comment to delete',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the comment was deleted',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainCommentCreateComment: {
+    lexicon: 1,
+    id: 'social.grain.comment.createComment',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a comment. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['text', 'subject'],
+            properties: {
+              text: {
+                type: 'string',
+                maxLength: 3000,
+                maxGraphemes: 300,
+              },
+              subject: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              focus: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              replyTo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              commentUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created comment',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainComment: {
     lexicon: 1,
     id: 'social.grain.comment',
···
       },
     },
   },
+  SocialGrainGalleryDeleteGallery: {
+    lexicon: 1,
+    id: 'social.grain.gallery.deleteGallery',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Delete a gallery. Does not delete the items in the gallery, just the gallery itself.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'Unique identifier of the gallery to delete',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the gallery was deleted',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainGalleryItem: {
     lexicon: 1,
     id: 'social.grain.gallery.item',
···
       },
     },
   },
+  SocialGrainGalleryCreateItem: {
+    lexicon: 1,
+    id: 'social.grain.gallery.createItem',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new gallery item',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['galleryUri', 'photoUri', 'position'],
+            properties: {
+              galleryUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the gallery to create the item in',
+              },
+              photoUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the photo to be added as an item',
+              },
+              position: {
+                type: 'integer',
+                description:
+                  'Position of the item in the gallery, used for ordering',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              itemUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created gallery item',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainGalleryCreateGallery: {
+    lexicon: 1,
+    id: 'social.grain.gallery.createGallery',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new gallery',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['title'],
+            properties: {
+              title: {
+                type: 'string',
+                maxLength: 100,
+              },
+              description: {
+                type: 'string',
+                maxLength: 1000,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              galleryUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created gallery',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainGalleryDefs: {
     lexicon: 1,
     id: 'social.grain.gallery.defs',
···
       },
     },
   },
+  SocialGrainGalleryDeleteItem: {
+    lexicon: 1,
+    id: 'social.grain.gallery.deleteItem',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a gallery item',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the gallery to create the item in',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the gallery item was deleted',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainGallery: {
     lexicon: 1,
     id: 'social.grain.gallery',
···
       },
     },
   },
+  SocialGrainGalleryUpdateGallery: {
+    lexicon: 1,
+    id: 'social.grain.gallery.updateGallery',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new gallery',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['galleryUri', 'title'],
+            properties: {
+              galleryUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'The AT-URI of the gallery to update',
+              },
+              title: {
+                type: 'string',
+              },
+              description: {
+                type: 'string',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the gallery was updated',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainGalleryApplySort: {
+    lexicon: 1,
+    id: 'social.grain.gallery.applySort',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Apply sorting to photos in a gallery. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['writes'],
+            properties: {
+              writes: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.gallery.applySort#update',
+                },
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the writes were successfully applied',
+              },
+            },
+          },
+        },
+      },
+      update: {
+        type: 'object',
+        required: ['itemUri', 'position'],
+        properties: {
+          itemUri: {
+            type: 'string',
+            format: 'at-uri',
+            description: 'AT URI of the item to update',
+          },
+          position: {
+            type: 'integer',
+            description:
+              'The position of the item in the gallery, used for ordering',
+          },
+        },
+      },
+    },
+  },
   SocialGrainGalleryGetGalleryThread: {
     lexicon: 1,
     id: 'social.grain.gallery.getGalleryThread',
···
       },
     },
   },
+  SocialGrainGraphDeleteFollow: {
+    lexicon: 1,
+    id: 'social.grain.graph.deleteFollow',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a follow relationship. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the follow record to delete',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the follow was deleted',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainGraphFollow: {
     lexicon: 1,
     id: 'social.grain.graph.follow',
···
       },
     },
   },
+  SocialGrainGraphCreateFollow: {
+    lexicon: 1,
+    id: 'social.grain.graph.createFollow',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a follow relationship between actors.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['subject'],
+            properties: {
+              subject: {
+                type: 'string',
+                format: 'at-identifier',
+                description: 'DID of the actor to follow.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              followUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created follow record.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainGraphGetFollowers: {
     lexicon: 1,
     id: 'social.grain.graph.getFollowers',
···
       },
     },
   },
+  SocialGrainFavoriteDeleteFavorite: {
+    lexicon: 1,
+    id: 'social.grain.favorite.deleteFavorite',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a favorite item by its ID.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'The AT URI of the favorite to delete.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['success'],
+            properties: {
+              success: {
+                type: 'boolean',
+                description:
+                  'Indicates if the favorite was successfully deleted.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainFavoriteCreateFavorite: {
+    lexicon: 1,
+    id: 'social.grain.favorite.createFavorite',
+    defs: {
+      main: {
+        description: 'Create a favorite for a given subject.',
+        type: 'procedure',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['subject'],
+            properties: {
+              subject: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'URI of the subject to favorite.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['favoriteUri'],
+            properties: {
+              favoriteUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI for the created favorite.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainFavorite: {
+    lexicon: 1,
+    id: 'social.grain.favorite',
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['createdAt', 'subject'],
+          properties: {
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+            subject: {
+              type: 'string',
+              format: 'at-uri',
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainLabelerDefs: {
     lexicon: 1,
     id: 'social.grain.labeler.defs',
···
       },
     },
   },
-  SocialGrainFavorite: {
-    lexicon: 1,
-    id: 'social.grain.favorite',
-    defs: {
-      main: {
-        type: 'record',
-        key: 'tid',
-        record: {
-          type: 'object',
-          required: ['createdAt', 'subject'],
-          properties: {
-            createdAt: {
-              type: 'string',
-              format: 'datetime',
-            },
-            subject: {
-              type: 'string',
-              format: 'at-uri',
-            },
-          },
-        },
-      },
-    },
-  },
   SocialGrainActorDefs: {
     lexicon: 1,
     id: 'social.grain.actor.defs',
···
       },
     },
   },
+  SocialGrainActorUpdateAvatar: {
+    lexicon: 1,
+    id: 'social.grain.actor.updateAvatar',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: "Update an actor's avatar. Requires auth.",
+        input: {
+          encoding: '*/*',
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description:
+                  'Indicates whether the avatar update was successful.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainActorGetActorFavs: {
     lexicon: 1,
     id: 'social.grain.actor.getActorFavs',
···
       },
     },
   },
+  SocialGrainActorUpdateProfile: {
+    lexicon: 1,
+    id: 'social.grain.actor.updateProfile',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: "Update an actor's profile info. Requires auth.",
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              displayName: {
+                type: 'string',
+                maxGraphemes: 64,
+                maxLength: 640,
+              },
+              description: {
+                type: 'string',
+                description: 'Free-form profile description text.',
+                maxGraphemes: 256,
+                maxLength: 2560,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description:
+                  'Indicates whether the profile update was successful.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainPhotoDefs: {
     lexicon: 1,
     id: 'social.grain.photo.defs',
···
       },
     },
   },
+  SocialGrainPhotoDeletePhoto: {
+    lexicon: 1,
+    id: 'social.grain.photo.deletePhoto',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Delete a favorite photo by its unique at-uri.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the photo to delete.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['success'],
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'Indicates if the photo was successfully deleted.',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainPhotoUploadPhoto: {
+    lexicon: 1,
+    id: 'social.grain.photo.uploadPhoto',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Upload a photo. Requires auth.',
+        input: {
+          encoding: '*/*',
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              photoUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created photo',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainPhotoCreateExif: {
+    lexicon: 1,
+    id: 'social.grain.photo.createExif',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Create a new Exif record for a photo',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['photo'],
+            properties: {
+              photo: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              dateTimeOriginal: {
+                type: 'string',
+                format: 'datetime',
+              },
+              exposureTime: {
+                type: 'integer',
+              },
+              fNumber: {
+                type: 'integer',
+              },
+              flash: {
+                type: 'string',
+              },
+              focalLengthIn35mmFormat: {
+                type: 'integer',
+              },
+              iSO: {
+                type: 'integer',
+              },
+              lensMake: {
+                type: 'string',
+              },
+              lensModel: {
+                type: 'string',
+              },
+              make: {
+                type: 'string',
+              },
+              model: {
+                type: 'string',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              exifUri: {
+                type: 'string',
+                format: 'at-uri',
+                description: 'AT URI of the created gallery',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainPhotoExif: {
     lexicon: 1,
     id: 'social.grain.photo.exif',
···
             model: {
               type: 'string',
             },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainPhotoApplyAlts: {
+    lexicon: 1,
+    id: 'social.grain.photo.applyAlts',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Apply alt texts to photos in a gallery. Requires auth.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['writes'],
+            properties: {
+              writes: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.photo.applyAlts#update',
+                },
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              success: {
+                type: 'boolean',
+                description: 'True if the writes were successfully applied',
+              },
+            },
+          },
+        },
+      },
+      update: {
+        type: 'object',
+        required: ['photoUri', 'alt'],
+        properties: {
+          photoUri: {
+            type: 'string',
+            format: 'at-uri',
+            description: 'AT URI of the item to update',
+          },
+          alt: {
+            type: 'string',
+            maxLength: 1000,
+            description: 'The alt text to apply to the photo',
           },
         },
       },
···
   SocialGrainNotificationGetNotifications:
     'social.grain.notification.getNotifications',
   SocialGrainCommentDefs: 'social.grain.comment.defs',
+  SocialGrainCommentDeleteComment: 'social.grain.comment.deleteComment',
+  SocialGrainCommentCreateComment: 'social.grain.comment.createComment',
   SocialGrainComment: 'social.grain.comment',
+  SocialGrainGalleryDeleteGallery: 'social.grain.gallery.deleteGallery',
   SocialGrainGalleryItem: 'social.grain.gallery.item',
+  SocialGrainGalleryCreateItem: 'social.grain.gallery.createItem',
+  SocialGrainGalleryCreateGallery: 'social.grain.gallery.createGallery',
   SocialGrainGalleryDefs: 'social.grain.gallery.defs',
+  SocialGrainGalleryDeleteItem: 'social.grain.gallery.deleteItem',
   SocialGrainGallery: 'social.grain.gallery',
+  SocialGrainGalleryUpdateGallery: 'social.grain.gallery.updateGallery',
+  SocialGrainGalleryApplySort: 'social.grain.gallery.applySort',
   SocialGrainGalleryGetGalleryThread: 'social.grain.gallery.getGalleryThread',
   SocialGrainGalleryGetActorGalleries: 'social.grain.gallery.getActorGalleries',
   SocialGrainGalleryGetGallery: 'social.grain.gallery.getGallery',
+  SocialGrainGraphDeleteFollow: 'social.grain.graph.deleteFollow',
   SocialGrainGraphFollow: 'social.grain.graph.follow',
+  SocialGrainGraphCreateFollow: 'social.grain.graph.createFollow',
   SocialGrainGraphGetFollowers: 'social.grain.graph.getFollowers',
   SocialGrainGraphGetFollows: 'social.grain.graph.getFollows',
+  SocialGrainFavoriteDeleteFavorite: 'social.grain.favorite.deleteFavorite',
+  SocialGrainFavoriteCreateFavorite: 'social.grain.favorite.createFavorite',
+  SocialGrainFavorite: 'social.grain.favorite',
   SocialGrainLabelerDefs: 'social.grain.labeler.defs',
   SocialGrainLabelerService: 'social.grain.labeler.service',
   SocialGrainFeedGetTimeline: 'social.grain.feed.getTimeline',
-  SocialGrainFavorite: 'social.grain.favorite',
   SocialGrainActorDefs: 'social.grain.actor.defs',
   SocialGrainActorGetProfile: 'social.grain.actor.getProfile',
   SocialGrainActorSearchActors: 'social.grain.actor.searchActors',
+  SocialGrainActorUpdateAvatar: 'social.grain.actor.updateAvatar',
   SocialGrainActorGetActorFavs: 'social.grain.actor.getActorFavs',
   SocialGrainActorProfile: 'social.grain.actor.profile',
+  SocialGrainActorUpdateProfile: 'social.grain.actor.updateProfile',
   SocialGrainPhotoDefs: 'social.grain.photo.defs',
+  SocialGrainPhotoDeletePhoto: 'social.grain.photo.deletePhoto',
+  SocialGrainPhotoUploadPhoto: 'social.grain.photo.uploadPhoto',
+  SocialGrainPhotoCreateExif: 'social.grain.photo.createExif',
   SocialGrainPhotoExif: 'social.grain.photo.exif',
+  SocialGrainPhotoApplyAlts: 'social.grain.photo.applyAlts',
   SocialGrainPhotoGetActorPhotos: 'social.grain.photo.getActorPhotos',
   SocialGrainPhoto: 'social.grain.photo',
   ComAtprotoLabelDefs: 'com.atproto.label.defs',

__generated__/types/social/grain/actor/updateAvatar.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import stream from "node:stream";
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.actor.updateAvatar";
+
+export interface QueryParams {}
+
+export type InputSchema = string | Uint8Array | Blob;
+
+export interface OutputSchema {
+  /** Indicates whether the avatar update was successful. */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "*/*";
+  body: stream.Readable;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/actor/updateProfile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.actor.updateProfile";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  displayName?: string;
+  /** Free-form profile description text. */
+  description?: string;
+}
+
+export interface OutputSchema {
+  /** Indicates whether the profile update was successful. */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/comment/createComment.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.comment.createComment";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  text: string;
+  subject: string;
+  focus?: string;
+  replyTo?: string;
+}
+
+export interface OutputSchema {
+  /** AT URI of the created comment */
+  commentUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/comment/deleteComment.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.comment.deleteComment";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** AT URI of the comment to delete */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** True if the comment was deleted */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/favorite/createFavorite.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.favorite.createFavorite";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** URI of the subject to favorite. */
+  subject: string;
+}
+
+export interface OutputSchema {
+  /** AT URI for the created favorite. */
+  favoriteUri: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/favorite/deleteFavorite.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.favorite.deleteFavorite";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The AT URI of the favorite to delete. */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** Indicates if the favorite was successfully deleted. */
+  success: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/applySort.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.applySort";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  writes: Update[];
+}
+
+export interface OutputSchema {
+  /** True if the writes were successfully applied */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;
+
+export interface Update {
+  $type?: "social.grain.gallery.applySort#update";
+  /** AT URI of the item to update */
+  itemUri: string;
+  /** The position of the item in the gallery, used for ordering */
+  position: number;
+}
+
+const hashUpdate = "update";
+
+export function isUpdate<V>(v: V) {
+  return is$typed(v, id, hashUpdate);
+}
+
+export function validateUpdate<V>(v: V) {
+  return validate<Update & V>(v, id, hashUpdate);
+}

__generated__/types/social/grain/gallery/createGallery.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.createGallery";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  title: string;
+  description?: string;
+}
+
+export interface OutputSchema {
+  /** AT URI of the created gallery */
+  galleryUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/createItem.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.createItem";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** AT URI of the gallery to create the item in */
+  galleryUri: string;
+  /** AT URI of the photo to be added as an item */
+  photoUri: string;
+  /** Position of the item in the gallery, used for ordering */
+  position: number;
+}
+
+export interface OutputSchema {
+  /** AT URI of the created gallery item */
+  itemUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/deleteGallery.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.deleteGallery";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** Unique identifier of the gallery to delete */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** True if the gallery was deleted */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/deleteItem.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.deleteItem";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** AT URI of the gallery to create the item in */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** True if the gallery item was deleted */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/gallery/updateGallery.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.updateGallery";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The AT-URI of the gallery to update */
+  galleryUri: string;
+  title: string;
+  description?: string;
+}
+
+export interface OutputSchema {
+  /** True if the gallery was updated */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/graph/createFollow.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.graph.createFollow";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** DID of the actor to follow. */
+  subject: string;
+}
+
+export interface OutputSchema {
+  /** AT URI of the created follow record. */
+  followUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/graph/deleteFollow.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.graph.deleteFollow";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** AT URI of the follow record to delete */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** True if the follow was deleted */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/photo/applyAlts.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.photo.applyAlts";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  writes: Update[];
+}
+
+export interface OutputSchema {
+  /** True if the writes were successfully applied */
+  success?: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;
+
+export interface Update {
+  $type?: "social.grain.photo.applyAlts#update";
+  /** AT URI of the item to update */
+  photoUri: string;
+  /** The alt text to apply to the photo */
+  alt: string;
+}
+
+const hashUpdate = "update";
+
+export function isUpdate<V>(v: V) {
+  return is$typed(v, id, hashUpdate);
+}
+
+export function validateUpdate<V>(v: V) {
+  return validate<Update & V>(v, id, hashUpdate);
+}

__generated__/types/social/grain/photo/createExif.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.photo.createExif";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  photo: string;
+  dateTimeOriginal?: string;
+  exposureTime?: number;
+  fNumber?: number;
+  flash?: string;
+  focalLengthIn35mmFormat?: number;
+  iSO?: number;
+  lensMake?: string;
+  lensModel?: string;
+  make?: string;
+  model?: string;
+}
+
+export interface OutputSchema {
+  /** AT URI of the created gallery */
+  exifUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/photo/deletePhoto.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.photo.deletePhoto";
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** AT URI of the photo to delete. */
+  uri: string;
+}
+
+export interface OutputSchema {
+  /** Indicates if the photo was successfully deleted. */
+  success: boolean;
+}
+
+export interface HandlerInput {
+  encoding: "application/json";
+  body: InputSchema;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

__generated__/types/social/grain/photo/uploadPhoto.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import stream from "node:stream";
+import { HandlerAuth, HandlerPipeThrough } from "npm:@atproto/xrpc-server";
+import express from "npm:express";
+import { validate as _validate } from "../../../../lexicons.ts";
+import { is$typed as _is$typed } from "../../../../util.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.photo.uploadPhoto";
+
+export interface QueryParams {}
+
+export type InputSchema = string | Uint8Array | Blob;
+
+export interface OutputSchema {
+  /** AT URI of the created photo */
+  photoUri?: string;
+}
+
+export interface HandlerInput {
+  encoding: "*/*";
+  body: stream.Readable;
+}
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+}
+
+export type HandlerOutput = HandlerError | HandlerSuccess | HandlerPipeThrough;
+export type HandlerReqCtx<HA extends HandlerAuth = never> = {
+  auth: HA;
+  params: QueryParams;
+  input: HandlerInput;
+  req: express.Request;
+  res: express.Response;
+  resetRouteRateLimits: () => Promise<void>;
+};
+export type Handler<HA extends HandlerAuth = never> = (
+  ctx: HandlerReqCtx<HA>,
+) => Promise<HandlerOutput> | HandlerOutput;

deno.json

···
     "$lexicon/": "./__generated__/",
     "@atproto/api": "npm:@atproto/api@^0.15.16",
     "@atproto/syntax": "npm:@atproto/syntax@^0.4.0",
-    "@bigmoves/bff": "jsr:@bigmoves/bff@0.3.0-beta.52",
+    "@bigmoves/bff": "jsr:@bigmoves/bff@0.3.0-beta.54",
     "@std/http": "jsr:@std/http@^1.0.17",
     "@std/path": "jsr:@std/path@^1.0.9",
     "@tailwindcss/cli": "npm:@tailwindcss/cli@^4.1.4",
···
     "exifr": "npm:exifr@^7.1.3",
     "htmx.org": "npm:htmx.org@^1.9.12",
     "hyperscript.org": "npm:hyperscript.org@^0.9.14",
+    "image-size": "npm:image-size@^2.0.2",
     "popmotion": "npm:popmotion@^11.0.5",
     "preact": "npm:preact@^10.26.5",
     "sortablejs": "npm:sortablejs@^1.15.6",

deno.lock

···
 {
   "version": "5",
   "specifiers": {
+    "jsr:@bigmoves/atproto-oauth-client@0.2": "0.2.0",
+    "jsr:@bigmoves/bff@0.3.0-beta.54": "0.3.0-beta.54",
     "jsr:@deno/gfm@0.10": "0.10.0",
     "jsr:@denosaurs/emoji@0.3": "0.3.1",
     "jsr:@luca/esbuild-deno-loader@~0.11.1": "0.11.1",
···
     "jsr:@std/assert@^1.0.13": "1.0.13",
     "jsr:@std/async@^1.0.12": "1.0.12",
     "jsr:@std/bytes@^1.0.2": "1.0.6",
+    "jsr:@std/cache@0.2": "0.2.0",
     "jsr:@std/cli@^1.0.16": "1.0.20",
     "jsr:@std/cli@^1.0.20": "1.0.20",
     "jsr:@std/data-structures@^1.0.6": "1.0.7",
···
     "npm:he@^1.2.0": "1.2.0",
     "npm:htmx.org@^1.9.12": "1.9.12",
     "npm:hyperscript.org@~0.9.14": "0.9.14",
+    "npm:image-size@^2.0.2": "2.0.2",
     "npm:jose@5.9.6": "5.9.6",
     "npm:jsonwebtoken@^9.0.2": "9.0.2",
     "npm:katex@0.16": "0.16.22",
···
     "npm:typed-htmx@~0.3.1": "0.3.1"
   },
   "jsr": {
+    "@bigmoves/atproto-oauth-client@0.2.0": {
+      "integrity": "5c3ca124dd52eff51dace83790779ebe48c4b41559b799e16c8750bd415f2124",
+      "dependencies": [
+        "npm:@atproto-labs/handle-resolver-node",
+        "npm:@atproto-labs/simple-store",
+        "npm:@atproto/jwk",
+        "npm:@atproto/oauth-client",
+        "npm:@atproto/oauth-types",
+        "npm:jose"
+      ]
+    },
+    "@bigmoves/bff@0.3.0-beta.54": {
+      "integrity": "b3f04813eb9039c142dfc22c7d9bba6a897a2149fd430a45405c9f2df776843a",
+      "dependencies": [
+        "jsr:@bigmoves/atproto-oauth-client",
+        "jsr:@std/assert@^1.0.13",
+        "jsr:@std/cache",
+        "jsr:@std/fmt",
+        "jsr:@std/http@^1.0.13",
+        "jsr:@std/path@^1.0.8",
+        "npm:@atproto/api@~0.15.7",
+        "npm:@atproto/common",
+        "npm:@atproto/identity",
+        "npm:@atproto/lexicon@0.4.11",
+        "npm:@atproto/lexicon@~0.4.11",
+        "npm:@atproto/oauth-client",
+        "npm:@atproto/syntax",
+        "npm:@atproto/xrpc-server@0.7.19",
+        "npm:clsx",
+        "npm:jsonwebtoken",
+        "npm:multiformats@^13.3.2",
+        "npm:preact",
+        "npm:preact-render-to-string",
+        "npm:tailwind-merge"
+      ]
+    },
     "@deno/gfm@0.10.0": {
       "integrity": "51708205e3559a4aeb6afb29d07c5bfafe7941f91bb360351ef6621de9a39527",
       "dependencies": [
···
     },
     "@std/bytes@1.0.6": {
       "integrity": "f6ac6adbd8ccd99314045f5703e23af0a68d7f7e58364b47d2c7f408aeb5820a"
+    },
+    "@std/cache@0.2.0": {
+      "integrity": "63a2ccd5a9e7c03e430f7d34dfcfd0d0cfc90731a1eaf8208f4c66e418fc3035"
     },
     "@std/cli@1.0.20": {
       "integrity": "a8c384a2c98cec6ec6a2055c273a916e2772485eb784af0db004c5ab8ba52333"
···
     "ieee754@1.2.1": {
       "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="
     },
+    "image-size@2.0.2": {
+      "integrity": "sha512-IRqXKlaXwgSMAMtpNzZa1ZAe8m+Sa1770Dhk8VkSsP9LS+iHD62Zd8FQKs8fbPiagBE7BzoFX23cxFnwshpV6w==",
+      "bin": true
+    },
     "inherits@2.0.4": {
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
···
   },
   "workspace": {
     "dependencies": [
-      "jsr:@bigmoves/bff@0.3.0-beta.52",
+      "jsr:@bigmoves/bff@0.3.0-beta.54",
       "jsr:@std/http@^1.0.17",
       "jsr:@std/path@^1.0.9",
       "npm:@atproto/api@~0.15.16",
···
       "npm:exifr@^7.1.3",
       "npm:htmx.org@^1.9.12",
       "npm:hyperscript.org@~0.9.14",
+      "npm:image-size@^2.0.2",
       "npm:popmotion@^11.0.5",
       "npm:preact@^10.26.5",
       "npm:sortablejs@^1.15.6",

lexicons/social/grain/actor/updateAvatar.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.actor.updateAvatar",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update an actor's avatar. Requires auth.",
+      "input": {
+        "encoding": "*/*"
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "Indicates whether the avatar update was successful."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/actor/updateProfile.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.actor.updateProfile",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Update an actor's profile info. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "displayName": {
+              "type": "string",
+              "maxGraphemes": 64,
+              "maxLength": 640
+            },
+            "description": {
+              "type": "string",
+              "description": "Free-form profile description text.",
+              "maxGraphemes": 256,
+              "maxLength": 2560
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "Indicates whether the profile update was successful."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/comment/createComment.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.comment.createComment",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a comment. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["text", "subject"],
+          "properties": {
+            "text": {
+              "type": "string",
+              "maxLength": 3000,
+              "maxGraphemes": 300
+            },
+            "subject": {
+              "type": "string",
+              "format": "at-uri"
+            },
+            "focus": {
+              "type": "string",
+              "format": "at-uri"
+            },
+            "replyTo": {
+              "type": "string",
+              "format": "at-uri"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "commentUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created comment"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/comment/deleteComment.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.comment.deleteComment",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a comment. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the comment to delete"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the comment was deleted"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/favorite/createFavorite.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.favorite.createFavorite",
+  "defs": {
+    "main": {
+      "description": "Create a favorite for a given subject.",
+      "type": "procedure",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["subject"],
+          "properties": {
+            "subject": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "URI of the subject to favorite."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["favoriteUri"],
+          "properties": {
+            "favoriteUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI for the created favorite."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/favorite/deleteFavorite.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.favorite.deleteFavorite",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a favorite item by its ID.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT URI of the favorite to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["success"],
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "Indicates if the favorite was successfully deleted."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/applySort.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.applySort",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Apply sorting to photos in a gallery. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["writes"],
+          "properties": {
+            "writes": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#update"
+              }
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the writes were successfully applied"
+            }
+          }
+        }
+      }
+    },
+    "update": {
+      "type": "object",
+      "required": ["itemUri", "position"],
+      "properties": {
+        "itemUri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "AT URI of the item to update"
+        },
+        "position": {
+          "type": "integer",
+          "description": "The position of the item in the gallery, used for ordering"
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/createGallery.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.createGallery",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new gallery",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["title"],
+          "properties": {
+            "title": { "type": "string", "maxLength": 100 },
+            "description": { "type": "string", "maxLength": 1000 }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "galleryUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created gallery"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/createItem.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.createItem",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new gallery item",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["galleryUri", "photoUri", "position"],
+          "properties": {
+            "galleryUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the gallery to create the item in"
+            },
+            "photoUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the photo to be added as an item"
+            },
+            "position": {
+              "type": "integer",
+              "description": "Position of the item in the gallery, used for ordering"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "itemUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created gallery item"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/deleteGallery.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.deleteGallery",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a gallery. Does not delete the items in the gallery, just the gallery itself.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "Unique identifier of the gallery to delete"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the gallery was deleted"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/deleteItem.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.deleteItem",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a gallery item",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the gallery to create the item in"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the gallery item was deleted"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/updateGallery.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.updateGallery",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new gallery",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["galleryUri", "title"],
+          "properties": {
+            "galleryUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "The AT-URI of the gallery to update"
+            },
+            "title": { "type": "string" },
+            "description": { "type": "string" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the gallery was updated"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/graph/createFollow.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.graph.createFollow",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a follow relationship between actors.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["subject"],
+          "properties": {
+            "subject": {
+              "type": "string",
+              "format": "at-identifier",
+              "description": "DID of the actor to follow."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "followUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created follow record."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/graph/deleteFollow.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.graph.deleteFollow",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a follow relationship. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the follow record to delete"
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the follow was deleted"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/photo/applyAlts.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.photo.applyAlts",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Apply alt texts to photos in a gallery. Requires auth.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["writes"],
+          "properties": {
+            "writes": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "#update"
+              }
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "True if the writes were successfully applied"
+            }
+          }
+        }
+      }
+    },
+    "update": {
+      "type": "object",
+      "required": ["photoUri", "alt"],
+      "properties": {
+        "photoUri": {
+          "type": "string",
+          "format": "at-uri",
+          "description": "AT URI of the item to update"
+        },
+        "alt": {
+          "type": "string",
+          "maxLength": 1000,
+          "description": "The alt text to apply to the photo"
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/photo/createExif.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.photo.createExif",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Create a new Exif record for a photo",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["photo"],
+          "properties": {
+            "photo": { "type": "string", "format": "at-uri" },
+            "dateTimeOriginal": { "type": "string", "format": "datetime" },
+            "exposureTime": { "type": "integer" },
+            "fNumber": { "type": "integer" },
+            "flash": { "type": "string" },
+            "focalLengthIn35mmFormat": { "type": "integer" },
+            "iSO": { "type": "integer" },
+            "lensMake": { "type": "string" },
+            "lensModel": { "type": "string" },
+            "make": { "type": "string" },
+            "model": { "type": "string" }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "exifUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created gallery"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/photo/deletePhoto.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.photo.deletePhoto",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Delete a favorite photo by its unique at-uri.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["uri"],
+          "properties": {
+            "uri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the photo to delete."
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["success"],
+          "properties": {
+            "success": {
+              "type": "boolean",
+              "description": "Indicates if the photo was successfully deleted."
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/photo/uploadPhoto.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.photo.uploadPhoto",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Upload a photo. Requires auth.",
+      "input": {
+        "encoding": "*/*"
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "photoUri": {
+              "type": "string",
+              "format": "at-uri",
+              "description": "AT URI of the created photo"
+            }
+          }
+        }
+      }
+    }
+  }
+}

src/api/mod.ts

···
   QueryParams as SearchActorsQueryParams,
 } from "$lexicon/types/social/grain/actor/searchActors.ts";
 import {
+  OutputSchema as UpdateAvatarOutputSchema,
+} from "$lexicon/types/social/grain/actor/updateAvatar.ts";
+import {
+  InputSchema as UpdateProfileInputSchema,
+  OutputSchema as UpdateProfileOutputSchema,
+} from "$lexicon/types/social/grain/actor/updateProfile.ts";
+import {
+  InputSchema as CreateCommentInputSchema,
+  OutputSchema as CreateCommentOutputSchema,
+} from "$lexicon/types/social/grain/comment/createComment.ts";
+import {
+  InputSchema as DeleteCommentInputSchema,
+  OutputSchema as DeleteCommentOutputSchema,
+} from "$lexicon/types/social/grain/comment/deleteComment.ts";
+import {
+  InputSchema as CreateFavoriteInputSchema,
+  OutputSchema as CreateFavoriteOutputSchema,
+} from "$lexicon/types/social/grain/favorite/createFavorite.ts";
+import {
+  InputSchema as DeleteFavoriteInputSchema,
+  OutputSchema as DeleteFavoriteOutputSchema,
+} from "$lexicon/types/social/grain/favorite/deleteFavorite.ts";
+import {
   OutputSchema as GetTimelineOutputSchema,
   QueryParams as GetTimelineQueryParams,
 } from "$lexicon/types/social/grain/feed/getTimeline.ts";
 import {
+  InputSchema as ApplySortInputSchema,
+  OutputSchema as ApplySortOutputSchema,
+} from "$lexicon/types/social/grain/gallery/applySort.ts";
+import {
+  InputSchema as CreateGalleryInputSchema,
+  OutputSchema as CreateGalleryOutputSchema,
+} from "$lexicon/types/social/grain/gallery/createGallery.ts";
+import {
+  InputSchema as CreateGalleryItemInputSchema,
+  OutputSchema as CreateGalleryItemOutputSchema,
+} from "$lexicon/types/social/grain/gallery/createItem.ts";
+import {
+  InputSchema as DeleteGalleryInputSchema,
+  OutputSchema as DeleteGalleryOutputSchema,
+} from "$lexicon/types/social/grain/gallery/deleteGallery.ts";
+import {
+  InputSchema as DeleteGalleryItemInputSchema,
+  OutputSchema as DeleteGalleryItemOutputSchema,
+} from "$lexicon/types/social/grain/gallery/deleteItem.ts";
+import {
   OutputSchema as GetActorGalleriesOutputSchema,
   QueryParams as GetActorGalleriesQueryParams,
 } from "$lexicon/types/social/grain/gallery/getActorGalleries.ts";
···
   QueryParams as GetGalleryThreadQueryParams,
 } from "$lexicon/types/social/grain/gallery/getGalleryThread.ts";
 import {
+  InputSchema as UpdateGalleryInputSchema,
+  OutputSchema as UpdateGalleryOutputSchema,
+} from "$lexicon/types/social/grain/gallery/updateGallery.ts";
+import {
+  InputSchema as CreateFollowInputSchema,
+  OutputSchema as CreateFollowOutputSchema,
+} from "$lexicon/types/social/grain/graph/createFollow.ts";
+import {
+  InputSchema as DeleteFollowInputSchema,
+  OutputSchema as DeleteFollowOutputSchema,
+} from "$lexicon/types/social/grain/graph/deleteFollow.ts";
+import {
   OutputSchema as GetFollowersOutputSchema,
   QueryParams as GetFollowersQueryParams,
 } from "$lexicon/types/social/grain/graph/getFollowers.ts";
···
 import {
   OutputSchema as GetNotificationsOutputSchema,
 } from "$lexicon/types/social/grain/notification/getNotifications.ts";
+import {
+  InputSchema as ApplyAltsInputSchema,
+  OutputSchema as ApplyAltsOutputSchema,
+} from "$lexicon/types/social/grain/photo/applyAlts.ts";
+import {
+  InputSchema as DeletePhotoInputSchema,
+  OutputSchema as DeletePhotoOutputSchema,
+} from "$lexicon/types/social/grain/photo/deletePhoto.ts";
 import {
   OutputSchema as GetActorPhotosOutputSchema,
   QueryParams as GetActorPhotosQueryParams,
 } from "$lexicon/types/social/grain/photo/getActorPhotos.ts";
-
+import {
+  OutputSchema as UploadPhotoOutputSchema,
+} from "$lexicon/types/social/grain/photo/uploadPhoto.ts";
 import { AtUri } from "@atproto/syntax";
 import { BffMiddleware, route } from "@bigmoves/bff";
+import { imageSize } from "image-size";
+import { Buffer } from "node:buffer";
 import {
   getActorGalleries,
   getActorGalleryFavs,
···
   getActorProfile,
   getActorProfileDetailed,
   searchActors,
+  updateActorProfile,
 } from "../lib/actor.ts";
-import { BadRequestError } from "../lib/errors.ts";
+import { XRPCError } from "../lib/errors.ts";
+import { createFavorite } from "../lib/favs.ts";
+import {
+  applySort,
+  createGallery,
+  createGalleryItem,
+  deleteGallery,
+  getGalleriesByHashtag,
+  getGallery,
+  updateGallery,
+} from "../lib/gallery.ts";
 import {
+  createFollow,
   getFollowersWithProfiles,
   getFollowingWithProfiles,
-} from "../lib/follow.ts";
-import { getGalleriesByHashtag, getGallery } from "../lib/gallery.ts";
+} from "../lib/graph.ts";
 import { getNotificationsDetailed } from "../lib/notifications.ts";
+import { applyAlts, createExif, createPhoto } from "../lib/photo.ts";
 import { getTimeline } from "../lib/timeline.ts";
-import { getGalleryComments } from "../modules/comments.tsx";
+import { createComment, getGalleryComments } from "../modules/comments.tsx";
 
 export const middlewares: BffMiddleware[] = [
+  route(
+    "/xrpc/social.grain.gallery.createGallery",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { title, description } = await parseCreateGalleryInputs(req);
+
+      try {
+        const galleryUri = await createGallery(ctx, { title, description });
+        return ctx.json({ galleryUri } satisfies CreateGalleryOutputSchema);
+      } catch (error) {
+        console.error("Error creating gallery:", error);
+        throw new XRPCError("InternalServerError", "Failed to create gallery");
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.gallery.updateGallery",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { galleryUri, title, description } = await parseUpdateGalleryInputs(
+        req,
+      );
+      const success = await updateGallery(ctx, galleryUri, {
+        title,
+        description,
+      });
+      return ctx.json(
+        { success } satisfies UpdateGalleryOutputSchema,
+      );
+    },
+  ),
+  route(
+    "/xrpc/social.grain.gallery.deleteGallery",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeleteGalleryInputs(
+        req,
+      );
+      const success = await deleteGallery(uri, ctx);
+      return ctx.json({ success } satisfies DeleteGalleryOutputSchema);
+    },
+  ),
+  route(
+    "/xrpc/social.grain.gallery.createItem",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { galleryUri, photoUri } = await parseCreateGalleryItemInputs(req);
+      const createdItemUri = await createGalleryItem(
+        ctx,
+        galleryUri,
+        photoUri,
+      );
+      if (!createdItemUri) {
+        return ctx.json(
+          { message: "Failed to create gallery item" },
+          400,
+        );
+      }
+      return ctx.json(
+        { itemUri: createdItemUri } satisfies CreateGalleryItemOutputSchema,
+      );
+    },
+  ),
+  route(
+    "/xrpc/social.grain.gallery.deleteItem",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeleteGalleryItemInputs(req);
+      try {
+        await ctx.deleteRecord(uri);
+      } catch (error) {
+        console.error("Error deleting gallery item:", error);
+        return ctx.json(
+          { success: false } satisfies DeleteGalleryItemOutputSchema,
+        );
+      }
+      return ctx.json(
+        { success: true } satisfies DeleteGalleryItemOutputSchema,
+      );
+    },
+  ),
+  route(
+    "/xrpc/social.grain.photo.uploadPhoto",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      if (!ctx.agent) {
+        return ctx.json(
+          { message: "Unauthorized" },
+          401,
+        );
+      }
+
+      const bytes = await req.arrayBuffer();
+      if (!bytes || bytes.byteLength === 0) {
+        throw new XRPCError("InvalidRequest", "Missing blob");
+      }
+      const MAX_SIZE = 1024 * 1024; // 1MB
+      if (bytes.byteLength > MAX_SIZE) {
+        throw new XRPCError(
+          "PayloadTooLarge",
+          "request entity too large",
+        );
+      }
+      const { width, height } = imageSize(Buffer.from(bytes));
+      const res = await ctx.agent.uploadBlob(new Uint8Array(bytes));
+      if (!res.success) {
+        return ctx.json(
+          { message: "Failed to upload photo" },
+          500,
+        );
+      }
+      const blobRef = res.data.blob;
+      const photoUri = await createPhoto(
+        {
+          photo: blobRef,
+          alt: "", // @TODO: make this optional
+          aspectRatio: {
+            width,
+            height,
+          },
+        },
+        ctx,
+      );
+      return ctx.json({ photoUri } as UploadPhotoOutputSchema);
+    },
+  ),
+  route(
+    "/xrpc/social.grain.photo.createExif",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const exifData = await parseExifInputs(req);
+      const exifUri = await createExif(
+        exifData,
+        ctx,
+      );
+      if (!exifUri) {
+        return ctx.json(
+          { message: "Failed to create EXIF data" },
+          500,
+        );
+      }
+      return ctx.json({ exifUri });
+    },
+  ),
+  route(
+    "/xrpc/social.grain.photo.deletePhoto",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeletePhotoInputs(req);
+      try {
+        await ctx.deleteRecord(uri);
+        return ctx.json({ success: true } satisfies DeletePhotoOutputSchema);
+      } catch (error) {
+        console.error("Error deleting photo:", error);
+        return ctx.json({ success: false } satisfies DeletePhotoOutputSchema);
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.graph.createFollow",
+    ["POST"],
+    async (req, _params, ctx) => {
+      const { did } = ctx.requireAuth();
+      const { subject } = await parseCreateFollowInputs(req);
+      if (!subject) {
+        throw new XRPCError("InvalidRequest", "Missing subject input");
+      }
+      try {
+        const followUri = await createFollow(did, subject, ctx);
+        return ctx.json({ followUri } satisfies CreateFollowOutputSchema);
+      } catch (error) {
+        console.error("Error creating follow:", error);
+        throw new XRPCError("InternalServerError", "Failed to create follow");
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.graph.deleteFollow",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeleteFollowInputs(req);
+      try {
+        await ctx.deleteRecord(uri);
+        return ctx.json({ success: true } satisfies DeleteFollowOutputSchema);
+      } catch (error) {
+        console.error("Error deleting follow:", error);
+        return ctx.json({ success: false } satisfies DeleteFollowOutputSchema);
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.favorite.createFavorite",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { subject } = await parseCreateFavoriteInputs(req);
+      try {
+        const favoriteUri = await createFavorite(subject, ctx);
+        return ctx.json({ favoriteUri } as CreateFavoriteOutputSchema);
+      } catch (error) {
+        console.error("Error creating favorite:", error);
+        throw new XRPCError("InternalServerError", "Failed to create favorite");
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.favorite.deleteFavorite",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeleteFavoriteInputs(req);
+      try {
+        await ctx.deleteRecord(uri);
+        return ctx.json({ success: true });
+      } catch (error) {
+        console.error("Error deleting favorite:", error);
+        return ctx.json({ success: false } as DeleteFavoriteOutputSchema);
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.comment.createComment",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { text, subject, focus, replyTo } = await parseCreateCommentInputs(
+        req,
+      );
+      try {
+        const commentUri = await createComment(
+          {
+            text,
+            subject,
+            focus,
+            replyTo,
+          },
+          ctx,
+        );
+        return ctx.json({ commentUri } satisfies CreateCommentOutputSchema);
+      } catch (error) {
+        console.error("Error creating comment:", error);
+        throw new XRPCError("InternalServerError", "Failed to create comment");
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.comment.deleteComment",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { uri } = await parseDeleteCommentInputs(req);
+      try {
+        await ctx.deleteRecord(uri);
+        return ctx.json({ success: true } satisfies DeleteCommentOutputSchema);
+      } catch (error) {
+        console.error("Error deleting comment:", error);
+        return ctx.json({ success: false } satisfies DeleteCommentOutputSchema);
+      }
+    },
+  ),
+  route(
+    "/xrpc/social.grain.actor.updateProfile",
+    ["POST"],
+    async (req, _params, ctx) => {
+      const { did } = ctx.requireAuth();
+      const { displayName, description } = await parseUpdateProfileInputs(req);
+      try {
+        await updateActorProfile(did, ctx, { displayName, description });
+      } catch (error) {
+        console.error("Error updating profile:", error);
+        ctx.json({ success: false } satisfies UpdateProfileOutputSchema);
+      }
+      return ctx.json({ success: true } satisfies UpdateProfileOutputSchema);
+    },
+  ),
+  route(
+    "/xrpc/social.grain.actor.updateAvatar",
+    ["POST"],
+    async (req, _params, ctx) => {
+      const { did } = ctx.requireAuth();
+      const bytes = await req.arrayBuffer();
+      if (!bytes || bytes.byteLength === 0) {
+        throw new XRPCError("InvalidRequest", "Missing avatar blob");
+      }
+      const MAX_SIZE = 1024 * 1024; // 1MB
+      if (bytes.byteLength > MAX_SIZE) {
+        throw new XRPCError(
+          "PayloadTooLarge",
+          "request entity too large",
+        );
+      }
+      if (!ctx.agent) {
+        throw new XRPCError("AuthenticationRequired");
+      }
+      const res = await ctx.agent.uploadBlob(new Uint8Array(bytes));
+      if (!res.success) {
+        throw new XRPCError("InternalServerError", "Failed to upload avatar");
+      }
+      const avatarBlob = res.data.blob;
+      try {
+        await updateActorProfile(did, ctx, { avatar: avatarBlob });
+      } catch (error) {
+        console.error("Error updating profile:", error);
+        throw new XRPCError("InternalServerError", "Failed to update profile");
+      }
+      return ctx.json({ success: true } satisfies UpdateAvatarOutputSchema);
+    },
+  ),
+  route(
+    "/xrpc/social.grain.photo.applyAlts",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { writes } = await parseApplyAltsInputs(req);
+      const success = await applyAlts(writes, ctx);
+      return ctx.json({ success } satisfies ApplyAltsOutputSchema);
+    },
+  ),
+  route(
+    "/xrpc/social.grain.gallery.applySort",
+    ["POST"],
+    async (req, _params, ctx) => {
+      ctx.requireAuth();
+      const { writes } = await parseApplySortInputs(req);
+      const success = await applySort(writes, ctx);
+      return ctx.json({ success } satisfies ApplySortOutputSchema);
+    },
+  ),
   route("/xrpc/social.grain.actor.getProfile", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { actor } = getProfileQueryParams(url);
     const profile = getActorProfileDetailed(actor, ctx);
-    return ctx.json(profile as GetProfileOutputSchema);
+    if (!profile) {
+      throw new XRPCError("NotFound", "Profile not found");
+    }
+    return ctx.json(profile satisfies GetProfileOutputSchema);
   }),
   route("/xrpc/social.grain.gallery.getActorGalleries", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { actor } = getActorGalleriesQueryParams(url);
     const galleries = getActorGalleries(actor, ctx);
-    return ctx.json({ items: galleries } as GetActorGalleriesOutputSchema);
+    return ctx.json(
+      { items: galleries } satisfies GetActorGalleriesOutputSchema,
+    );
   }),
   route("/xrpc/social.grain.actor.getActorFavs", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { actor } = getActorFavsQueryParams(url);
     const galleries = getActorGalleryFavs(actor, ctx);
-    return ctx.json({ items: galleries } as GetActorFavsOutputSchema);
+    return ctx.json({ items: galleries } satisfies GetActorFavsOutputSchema);
   }),
   route("/xrpc/social.grain.photo.getActorPhotos", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { actor } = getActorPhotosQueryParams(url);
     const photos = getActorPhotos(actor, ctx);
-    return ctx.json({ items: photos } as GetActorPhotosOutputSchema);
+    return ctx.json({ items: photos } satisfies GetActorPhotosOutputSchema);
   }),
   route("/xrpc/social.grain.gallery.getGallery", (req, _params, ctx) => {
     const url = new URL(req.url);
···
     const rkey = atUri.rkey;
     const gallery = getGallery(did, rkey, ctx);
     if (!gallery) {
-      return ctx.json({ message: "Gallery not found" }, 404);
+      throw new XRPCError("NotFound", "Gallery not found");
     }
-    return ctx.json(gallery as GetGalleryOutputSchema);
+    return ctx.json(gallery satisfies GetGalleryOutputSchema);
   }),
   route("/xrpc/social.grain.gallery.getGalleryThread", (req, _params, ctx) => {
     const url = new URL(req.url);
···
     const rkey = atUri.rkey;
     const gallery = getGallery(did, rkey, ctx);
     if (!gallery) {
-      return ctx.json({ message: "Gallery not found" }, 404);
+      throw new XRPCError("NotFound", "Gallery not found");
     }
     const comments = getGalleryComments(uri, ctx);
-    return ctx.json({ gallery, comments } as GetGalleryThreadOutputSchema);
+    return ctx.json(
+      { gallery, comments } satisfies GetGalleryThreadOutputSchema,
+    );
   }),
   route("/xrpc/social.grain.feed.getTimeline", async (req, _params, ctx) => {
     const url = new URL(req.url);
···
       const galleries = getGalleriesByHashtag(tag, ctx);
 
       return ctx.json(
-        { feed: galleries } as GetTimelineOutputSchema,
+        { feed: galleries } satisfies GetTimelineOutputSchema,
       );
     }
 
···
       "grain",
     );
     return ctx.json(
-      { feed: items.map((i) => i.gallery) } as GetTimelineOutputSchema,
+      { feed: items.map((i) => i.gallery) } satisfies GetTimelineOutputSchema,
     );
   }),
   route(
···
         ctx,
       );
       return ctx.json(
-        { notifications } as GetNotificationsOutputSchema,
+        { notifications } satisfies GetNotificationsOutputSchema,
       );
     },
   ),
···
         );
       }
       return ctx.json(
-        { actors: results } as SearchActorsOutputSchema,
+        { actors: results } satisfies SearchActorsOutputSchema,
       );
     },
   ),
···
     const url = new URL(req.url);
     const { actor } = getFollowsQueryParams(url);
     const subject = getActorProfile(actor, ctx);
+    if (!subject) {
+      throw new XRPCError("NotFound", "Actor not found");
+    }
     const follows = getFollowingWithProfiles(actor, ctx);
-    return ctx.json({
-      subject,
-      follows,
-    } as GetFollowsOutputSchema);
+    return ctx.json(
+      {
+        subject,
+        follows,
+      } satisfies GetFollowsOutputSchema,
+    );
   }),
   route("/xrpc/social.grain.graph.getFollowers", (req, _params, ctx) => {
     const url = new URL(req.url);
     const { actor } = getFollowersQueryParams(url);
     const subject = getActorProfile(actor, ctx);
+    if (!subject) {
+      throw new XRPCError("NotFound", "Subject not found");
+    }
     const followers = getFollowersWithProfiles(actor, ctx);
-    return ctx.json({
-      subject,
-      followers,
-    } as GetFollowersOutputSchema);
+    return ctx.json(
+      {
+        subject,
+        followers,
+      } satisfies GetFollowersOutputSchema,
+    );
   }),
   route(
     "/xrpc/social.grain.notification.updateSeen",
···
     async (req, _params, ctx) => {
       ctx.requireAuth();
       const json = await req.json();
-      const seenAt = json.seenAt as string ?? undefined;
+      const seenAt = json.seenAt satisfies string ?? undefined;
       if (!seenAt) {
-        throw new BadRequestError("Missing seenAt input");
+        throw new XRPCError("InvalidRequest", "Missing seenAt input");
       }
       ctx.updateSeen(seenAt);
       return ctx.json(null);
···
 
 function getProfileQueryParams(url: URL): GetProfileQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   return { actor };
 }
 
 function getActorGalleriesQueryParams(url: URL): GetActorGalleriesQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { actor, limit, cursor };
···
 
 function getActorFavsQueryParams(url: URL): GetActorFavsQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { actor, limit, cursor };
···
 
 function getActorPhotosQueryParams(url: URL): GetActorPhotosQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { actor, limit, cursor };
···
 
 function getGalleryQueryParams(url: URL): GetGalleryQueryParams {
   const uri = url.searchParams.get("uri");
-  if (!uri) throw new BadRequestError("Missing uri parameter");
+  if (!uri) throw new XRPCError("InvalidRequest", "Missing uri parameter");
   return { uri };
 }
 
 function getGalleryThreadQueryParams(url: URL): GetGalleryThreadQueryParams {
   const uri = url.searchParams.get("uri");
-  if (!uri) throw new BadRequestError("Missing uri parameter");
+  if (!uri) throw new XRPCError("InvalidRequest", "Missing uri parameter");
   return { uri };
 }
 
 function searchActorsQueryParams(url: URL): SearchActorsQueryParams {
   const q = url.searchParams.get("q");
-  if (!q) throw new BadRequestError("Missing q parameter");
+  if (!q) throw new XRPCError("InvalidRequest", "Missing q parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { q, limit, cursor };
···
 
 function getFollowsQueryParams(url: URL): GetFollowsQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { actor, limit, cursor };
···
 
 function getFollowersQueryParams(url: URL): GetFollowersQueryParams {
   const actor = url.searchParams.get("actor");
-  if (!actor) throw new BadRequestError("Missing actor parameter");
+  if (!actor) throw new XRPCError("InvalidRequest", "Missing actor parameter");
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { actor, limit, cursor };
···
   const algorithm = url.searchParams.get("algorithm") ?? undefined;
   const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
   if (isNaN(limit) || limit <= 0) {
-    throw new BadRequestError("Invalid limit parameter");
+    throw new XRPCError("InvalidRequest", "Invalid limit parameter");
   }
   const cursor = url.searchParams.get("cursor") ?? undefined;
   return { algorithm, limit, cursor };
 }
+
+async function parseCreateGalleryInputs(
+  req: Request,
+): Promise<CreateGalleryInputSchema> {
+  const body = await req.json();
+  const title = typeof body.title === "string" ? body.title : undefined;
+  if (!title) {
+    throw new XRPCError("InvalidRequest", "Missing title input");
+  }
+  const description = typeof body.description === "string"
+    ? body.description
+    : undefined;
+  return { title, description };
+}
+
+async function parseUpdateGalleryInputs(
+  req: Request,
+): Promise<UpdateGalleryInputSchema> {
+  const body = await req.json();
+  const title = typeof body.title === "string" ? body.title : undefined;
+  if (!title) {
+    throw new XRPCError("InvalidRequest", "Missing title input");
+  }
+  const description = typeof body.description === "string"
+    ? body.description
+    : undefined;
+  const galleryUri = typeof body.galleryUri === "string"
+    ? body.galleryUri
+    : undefined;
+  if (!galleryUri) {
+    throw new XRPCError("InvalidRequest", "Missing galleryUri input");
+  }
+  return { title, description, galleryUri };
+}
+
+async function parseDeleteGalleryInputs(
+  req: Request,
+): Promise<DeleteGalleryInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseCreateGalleryItemInputs(
+  req: Request,
+): Promise<CreateGalleryItemInputSchema> {
+  const body = await req.json();
+  const galleryUri = typeof body.galleryUri === "string"
+    ? body.galleryUri
+    : undefined;
+  if (!galleryUri) {
+    throw new XRPCError("InvalidRequest", "Missing galleryUri input");
+  }
+  const photoUri = typeof body.photoUri === "string"
+    ? body.photoUri
+    : undefined;
+  if (!photoUri) {
+    throw new XRPCError("InvalidRequest", "Missing photoUri input");
+  }
+  const position = typeof body.position === "number"
+    ? body.position
+    : undefined;
+  if (position === undefined) {
+    throw new XRPCError("InvalidRequest", "Missing position input");
+  }
+  return { galleryUri, photoUri, position };
+}
+
+async function parseDeleteGalleryItemInputs(
+  req: Request,
+): Promise<DeleteGalleryItemInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseDeletePhotoInputs(
+  req: Request,
+): Promise<DeletePhotoInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseCreateFollowInputs(
+  req: Request,
+): Promise<CreateFollowInputSchema> {
+  const body = await req.json();
+  const subject = typeof body.subject === "string" ? body.subject : undefined;
+  if (!subject) {
+    throw new XRPCError("InvalidRequest", "Missing subject input");
+  }
+  return { subject };
+}
+
+async function parseDeleteFollowInputs(
+  req: Request,
+): Promise<DeleteFollowInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseCreateFavoriteInputs(
+  req: Request,
+): Promise<CreateFavoriteInputSchema> {
+  const body = await req.json();
+  const subject = typeof body.subject === "string" ? body.subject : undefined;
+  if (!subject) {
+    throw new XRPCError("InvalidRequest", "Missing subject input");
+  }
+  return { subject };
+}
+
+async function parseDeleteFavoriteInputs(
+  req: Request,
+): Promise<DeleteFavoriteInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseCreateCommentInputs(
+  req: Request,
+): Promise<CreateCommentInputSchema> {
+  const body = await req.json();
+  const text = typeof body.text === "string" ? body.text : undefined;
+  if (!text) {
+    throw new XRPCError("InvalidRequest", "Missing text input");
+  }
+  const subject = typeof body.subject === "string" ? body.subject : undefined;
+  if (!subject) {
+    throw new XRPCError("InvalidRequest", "Missing subject input");
+  }
+  const focus = typeof body.focus === "string" ? body.focus : undefined;
+  const replyTo = typeof body.replyTo === "string" ? body.replyTo : undefined;
+  return { text, subject, focus, replyTo };
+}
+
+async function parseDeleteCommentInputs(
+  req: Request,
+): Promise<DeleteCommentInputSchema> {
+  const body = await req.json();
+  const uri = typeof body.uri === "string" ? body.uri : undefined;
+  if (!uri) {
+    throw new XRPCError("InvalidRequest", "Missing uri input");
+  }
+  return { uri };
+}
+
+async function parseUpdateProfileInputs(
+  req: Request,
+): Promise<UpdateProfileInputSchema> {
+  const body = await req.json();
+  const displayName = typeof body.displayName === "string"
+    ? body.displayName
+    : undefined;
+  if (!displayName) {
+    throw new XRPCError("InvalidRequest", "Missing displayName input");
+  }
+  const description = typeof body.description === "string"
+    ? body.description
+    : undefined;
+  return { displayName, description };
+}
+
+async function parseApplyAltsInputs(
+  req: Request,
+): Promise<ApplyAltsInputSchema> {
+  const body = await req.json();
+  if (!body || typeof body !== "object" || !Array.isArray(body.writes)) {
+    throw new XRPCError("InvalidRequest", "Missing or invalid writes array");
+  }
+  const writes = Array.isArray(body.writes)
+    ? body.writes.filter(
+      (item: unknown): item is { photoUri: string; alt: string } =>
+        typeof item === "object" &&
+        item !== null &&
+        typeof (item as { photoUri?: unknown }).photoUri === "string" &&
+        typeof (item as { alt?: unknown }).alt === "string",
+    )
+    : [];
+  return { writes };
+}
+
+async function parseApplySortInputs(
+  req: Request,
+): Promise<ApplySortInputSchema> {
+  const body = await req.json();
+  const writes = Array.isArray(body.writes) && body.writes.every(
+      (item: unknown): item is { itemUri: string; position: number } =>
+        typeof item === "object" &&
+        item !== null &&
+        typeof (item as { itemUri?: unknown }).itemUri === "string" &&
+        typeof (item as { position?: unknown }).position === "number",
+    )
+    ? body.writes
+    : [];
+  return { writes };
+}
+
+async function parseExifInputs(
+  req: Request,
+): Promise<{
+  photo: string;
+  dateTimeOriginal?: string;
+  exposureTime?: number;
+  fNumber?: number;
+  flash?: string;
+  focalLengthIn35mmFormat?: number;
+  iSO?: number;
+  lensMake?: string;
+  lensModel?: string;
+  make?: string;
+  model?: string;
+}> {
+  const body = await req.json();
+  const photo = typeof body.photo === "string" ? body.photo : undefined;
+  if (!photo) {
+    throw new XRPCError("InvalidRequest", "Missing photo input");
+  }
+  const dateTimeOriginal = typeof body.dateTimeOriginal === "string"
+    ? body.dateTimeOriginal
+    : undefined;
+  const exposureTime = typeof body.exposureTime === "number"
+    ? body.exposureTime
+    : undefined;
+  const fNumber = typeof body.fNumber === "number" ? body.fNumber : undefined;
+  const flash = typeof body.flash === "string" ? body.flash : undefined;
+  const focalLengthIn35mmFormat =
+    typeof body.focalLengthIn35mmFormat === "number"
+      ? body.focalLengthIn35mmFormat
+      : undefined;
+  const iSO = typeof body.iSO === "number" ? body.iSO : undefined;
+  const lensMake = typeof body.lensMake === "string"
+    ? body.lensMake
+    : undefined;
+  const lensModel = typeof body.lensModel === "string"
+    ? body.lensModel
+    : undefined;
+  const make = typeof body.make === "string" ? body.make : undefined;
+  const model = typeof body.model === "string" ? body.model : undefined;
+
+  return {
+    photo,
+    dateTimeOriginal,
+    exposureTime,
+    fNumber,
+    flash,
+    focalLengthIn35mmFormat,
+    iSO,
+    lensMake,
+    lensModel,
+    make,
+    model,
+  };
+}

src/lib/actor.ts

···
 import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
 import { $Typed } from "$lexicon/util.ts";
 import { BffContext, WithBffMeta } from "@bigmoves/bff";
-import { getFollow, getFollowersCount, getFollowsCount } from "./follow.ts";
 import {
   galleryToView,
   getGalleryCameras,
   getGalleryItemsAndPhotos,
 } from "./gallery.ts";
+import { getFollow, getFollowersCount, getFollowsCount } from "./graph.ts";
 import { photoToView, photoUrl } from "./photo.ts";
 import type { SocialNetwork } from "./timeline.ts";
 
···
 
   return profileViews;
 }
+
+export async function updateActorProfile(
+  did: string,
+  ctx: BffContext,
+  params: {
+    displayName?: string;
+    description?: string;
+    avatar?: GrainProfile["avatar"];
+  },
+) {
+  const record = ctx.indexService.getRecord<WithBffMeta<GrainProfile>>(
+    `at://${did}/social.grain.actor.profile/self`,
+  );
+  if (!record) return null;
+
+  const updated = await ctx.updateRecord<GrainProfile>(
+    "social.grain.actor.profile",
+    "self",
+    {
+      displayName: params.displayName ?? record.displayName,
+      description: params.description ?? record.description,
+      avatar: params.avatar ?? record.avatar,
+    },
+  );
+  return updated;
+}

src/lib/errors.ts

···
   });
 }
 
+function jsonErrorResponse(err: XRPCError): Response {
+  return new Response(JSON.stringify(err.toJSON()), {
+    status: err.status,
+    headers: {
+      "Content-Type": "application/json",
+    },
+  });
+}
+
 export function onError(err: unknown): Response {
+  if (err instanceof XRPCError) {
+    return jsonErrorResponse(err);
+  }
   if (err instanceof BadRequestError) {
     return errorResponse(err.message, 400);
   }
···
     this.name = "BadRequestError";
   }
 }
+
+const XRPCErrorCodes = {
+  InvalidRequest: 400,
+  NotFound: 404,
+  InternalServerError: 500,
+  AuthenticationRequired: 401,
+  PayloadTooLarge: 413,
+} as const;
+
+type XRPCErrorCode = keyof typeof XRPCErrorCodes;
+
+export class XRPCError extends Error {
+  code: XRPCErrorCode;
+  error?: unknown;
+
+  constructor(code: XRPCErrorCode, error?: unknown) {
+    super(typeof error === "string" ? error : code);
+    this.name = "XRPCError";
+    this.code = code;
+    this.error = error;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, XRPCError);
+    }
+  }
+
+  get status(): number {
+    return XRPCErrorCodes[this.code];
+  }
+
+  toJSON() {
+    return {
+      error: this.code,
+      message: this.message,
+    };
+  }
+}

src/lib/favs.ts

···
+import { Record as Favorite } from "$lexicon/types/social/grain/favorite.ts";
+import { BffContext, WithBffMeta } from "@bigmoves/bff";
+
+export function createFavorite(
+  subject: string,
+  ctx: BffContext,
+): Promise<string> {
+  return ctx.createRecord<WithBffMeta<Favorite>>("social.grain.favorite", {
+    subject,
+    createdAt: new Date().toISOString(),
+  });
+}

src/lib/follow.ts src/lib/graph.ts

···
     },
   );
 }
+
+export async function createFollow(
+  followerDid: string,
+  followeeDid: string,
+  ctx: BffContext,
+): Promise<string> {
+  const followUri = await ctx.createRecord<GrainFollow>(
+    "social.grain.graph.follow",
+    {
+      did: followerDid,
+      subject: followeeDid,
+      createdAt: new Date().toISOString(),
+    },
+  );
+  return followUri;
+}

src/lib/gallery.ts

···
 } from "$lexicon/types/social/grain/photo/defs.ts";
 import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
 import { $Typed, Un$Typed } from "$lexicon/util.ts";
+import { Facet } from "@atproto/api";
 import { AtUri } from "@atproto/syntax";
 import { BffContext, WithBffMeta } from "@bigmoves/bff";
 import { getGalleryCommentsCount } from "../modules/comments.tsx";
 import { getActorProfile, getActorProfilesBulk } from "./actor.ts";
 import { photoToView } from "./photo.ts";
+import { parseFacetedText } from "./rich_text.ts";
 
 type PhotoWithMeta = WithBffMeta<Photo> & {
   item?: WithBffMeta<GalleryItem>;
···
 }
 
 export async function deleteGallery(uri: string, ctx: BffContext) {
-  await ctx.deleteRecord(uri);
-  const { items: galleryItems } = ctx.indexService.getRecords<
-    WithBffMeta<GalleryItem>
-  >("social.grain.gallery.item", {
-    where: [{ field: "gallery", equals: uri }],
-  });
-  for (const item of galleryItems) {
-    await ctx.deleteRecord(item.uri);
-  }
-  const { items: favs } = ctx.indexService.getRecords<WithBffMeta<Favorite>>(
-    "social.grain.favorite",
-    {
-      where: [{ field: "subject", equals: uri }],
-    },
-  );
-  for (const fav of favs) {
-    await ctx.deleteRecord(fav.uri);
+  try {
+    await ctx.deleteRecord(uri);
+    const { items: galleryItems } = ctx.indexService.getRecords<
+      WithBffMeta<GalleryItem>
+    >("social.grain.gallery.item", {
+      where: [{ field: "gallery", equals: uri }],
+    });
+    for (const item of galleryItems) {
+      await ctx.deleteRecord(item.uri);
+    }
+    const { items: favs } = ctx.indexService.getRecords<WithBffMeta<Favorite>>(
+      "social.grain.favorite",
+      {
+        where: [{ field: "subject", equals: uri }],
+      },
+    );
+    for (const fav of favs) {
+      await ctx.deleteRecord(fav.uri);
+    }
+  } catch (error) {
+    console.error("Failed to delete gallery:", error);
+    return false;
   }
+  return true;
 }
 
 export function getGalleryFavs(galleryUri: string, ctx: BffContext) {
···
     ctx,
   );
 }
+
+export function createGallery(
+  ctx: BffContext,
+  {
+    title,
+    description,
+  }: {
+    title: string;
+    description?: string;
+  },
+): Promise<string> {
+  let facets: Facet[] | undefined = undefined;
+  if (description) {
+    try {
+      const resp = parseFacetedText(description, ctx);
+      facets = resp.facets;
+    } catch (e) {
+      console.error("Failed to parse facets:", e);
+    }
+  }
+
+  return ctx.createRecord<Gallery>(
+    "social.grain.gallery",
+    {
+      title,
+      description,
+      facets,
+      updatedAt: new Date().toISOString(),
+      createdAt: new Date().toISOString(),
+    },
+  );
+}
+
+export async function updateGallery(
+  ctx: BffContext,
+  uri: string,
+  {
+    title,
+    description,
+  }: {
+    title: string;
+    description?: string;
+  },
+): Promise<boolean> {
+  let facets: Facet[] | undefined = undefined;
+  if (description) {
+    try {
+      const resp = parseFacetedText(description, ctx);
+      facets = resp.facets;
+    } catch (e) {
+      console.error("Failed to parse facets:", e);
+    }
+  }
+
+  const gallery = ctx.indexService.getRecord<WithBffMeta<Gallery>>(uri);
+  if (!gallery) return false;
+  const rkey = new AtUri(uri).rkey;
+  await ctx.updateRecord<Gallery>(
+    "social.grain.gallery",
+    rkey,
+    {
+      title,
+      description,
+      facets,
+      updatedAt: new Date().toISOString(),
+      createdAt: gallery.createdAt,
+    },
+  );
+  return true;
+}
+
+export async function createGalleryItem(
+  ctx: BffContext,
+  galleryUri: string,
+  itemUri: string,
+): Promise<string | null> {
+  const count = ctx.indexService.countRecords(
+    "social.grain.gallery.item",
+    {
+      where: [
+        { field: "gallery", equals: galleryUri },
+      ],
+    },
+  );
+  const position = count ?? 0;
+  const createdItemUri = await ctx.createRecord<GalleryItem>(
+    "social.grain.gallery.item",
+    {
+      gallery: galleryUri,
+      item: itemUri,
+      position,
+      createdAt: new Date().toISOString(),
+    },
+  );
+  return createdItemUri;
+}
+
+export async function removeGalleryItem(
+  ctx: BffContext,
+  galleryUri: string,
+  photoUri: string,
+): Promise<boolean> {
+  const { items: galleryItems } = ctx.indexService.getRecords<
+    WithBffMeta<GalleryItem>
+  >(
+    "social.grain.gallery.item",
+    {
+      where: [
+        { field: "gallery", equals: galleryUri },
+        { field: "item", equals: photoUri },
+      ],
+    },
+  );
+  if (!galleryItems.length) return false;
+  for (const item of galleryItems) {
+    await ctx.deleteRecord(item.uri);
+  }
+  return true;
+}
+
+export async function applySort(
+  writes: Array<{
+    itemUri: string;
+    position: number;
+  }>,
+  ctx: BffContext,
+): Promise<boolean> {
+  const urisToUpdate = writes.map((update) => update.itemUri);
+
+  const { items: galleryItems } = ctx.indexService.getRecords<
+    WithBffMeta<GalleryItem>
+  >(
+    "social.grain.gallery.item",
+    {
+      where: [
+        { field: "uri", in: urisToUpdate },
+      ],
+    },
+  );
+
+  const positionMap = new Map<string, number>();
+  for (const update of writes) {
+    positionMap.set(update.itemUri, update.position);
+  }
+
+  const updates = galleryItems.map((item) => {
+    // Use position from positionMap if it exists (including 0)
+    const hasPosition = positionMap.has(item.uri);
+    return {
+      collection: "social.grain.gallery.item",
+      rkey: new AtUri(item.uri).rkey,
+      data: {
+        ...item,
+        position: hasPosition ? positionMap.get(item.uri) : item.position,
+      },
+    };
+  });
+
+  try {
+    await ctx.updateRecords(updates);
+  } catch (error) {
+    console.error("Failed to update gallery item positions:", error);
+    return false;
+  }
+
+  return true;
+}

src/lib/photo.ts

···
 import { ExifView, PhotoView } from "$lexicon/types/social/grain/photo/defs.ts";
 import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
 import { $Typed } from "$lexicon/util.ts";
+import { AtUri } from "@atproto/syntax";
 import { BffContext, WithBffMeta } from "@bigmoves/bff";
 import { format, parseISO } from "date-fns";
 import { PUBLIC_URL, USE_CDN } from "../env.ts";
···
     photoToView(photo.did, photo, exifMap.get(photo.uri))
   );
 }
+
+export async function createPhoto(
+  data: Partial<Photo>,
+  ctx: BffContext,
+): Promise<string> {
+  const photoUri = await ctx.createRecord<Photo>(
+    "social.grain.photo",
+    {
+      photo: data.photo,
+      alt: data.alt || "",
+      aspectRatio: data.aspectRatio || undefined,
+      createdAt: new Date().toISOString(),
+    },
+  );
+  return photoUri;
+}
+
+export async function createExif(
+  data: Partial<PhotoExif>,
+  ctx: BffContext,
+): Promise<string> {
+  const exifUri = await ctx.createRecord<PhotoExif>(
+    "social.grain.photo.exif",
+    {
+      ...data,
+      createdAt: new Date().toISOString(),
+    },
+  );
+  return exifUri;
+}
+
+export async function applyAlts(
+  writes: Array<{
+    photoUri: string;
+    alt: string;
+  }>,
+  ctx: BffContext,
+): Promise<boolean> {
+  const altMap = new Map<string, string>();
+  for (const update of writes) {
+    altMap.set(update.photoUri, update.alt);
+  }
+
+  const urisToUpdate = writes.map((update) => update.photoUri);
+
+  const { items: photoRecords } = ctx.indexService.getRecords<
+    WithBffMeta<Photo>
+  >(
+    "social.grain.photo",
+    {
+      where: [{ field: "uri", in: urisToUpdate }],
+    },
+  );
+
+  const updates = photoRecords.map((record) => ({
+    collection: "social.grain.photo",
+    rkey: new AtUri(record.uri).rkey,
+    data: { ...record, alt: altMap.get(record.uri) ?? record.alt ?? undefined },
+  }));
+
+  try {
+    await ctx.updateRecords(updates);
+  } catch (error) {
+    console.error("Failed to update photo alts:", error);
+    return false;
+  }
+
+  return true;
+}

src/modules/comments.tsx

···
   );
 }
 
+export function createComment(
+  data: Partial<Comment>,
+  ctx: BffContext,
+): Promise<string> {
+  let facets: Facet[] | undefined = undefined;
+  const resp = parseFacetedText(data.text ?? "", ctx);
+  facets = resp.facets;
+  return ctx.createRecord<WithBffMeta<Comment>>(
+    "social.grain.comment",
+    {
+      ...data,
+      facets,
+      createdAt: new Date().toISOString(),
+    },
+  );
+}
+
 export const middlewares: BffMiddleware[] = [
   // Actions
   route(
···
 
       const form = await req.formData();
       const text = form.get("text") as string;
-      const focus = form.get("focus") as string;
-      const replyTo = form.get("replyTo") as string;
+      const focus = form.get("focus") as string ?? undefined;
+      const replyTo = form.get("replyTo") as string ?? undefined;
 
       if (typeof text !== "string" || text.length === 0) {
         return new Response("Text is required", { status: 400 });
       }
-
-      let facets: Facet[] | undefined = undefined;
-      if (text) {
-        try {
-          const resp = parseFacetedText(text, ctx);
-          facets = resp.facets;
-        } catch (e) {
-          console.error("Failed to parse facets:", e);
-        }
-      }
-
       try {
-        await ctx.createRecord<WithBffMeta<Comment>>(
-          "social.grain.comment",
-          {
-            text,
-            facets,
-            subject: gallery.uri,
-            focus: focus ?? undefined,
-            replyTo: replyTo ?? undefined,
-            createdAt: new Date().toISOString(),
-          },
-        );
+        await createComment({
+          subject: gallery.uri,
+          text,
+          focus,
+          replyTo,
+        }, ctx);
       } catch (error) {
-        console.error("Error creating comment:", error);
-        if (error instanceof Error) {
-          throw new BadRequestError(error.message);
-        } else {
-          throw new BadRequestError("Unknown error");
+        if (error instanceof BadRequestError) {
+          return new Response(error.message, { status: 400 });
         }
+        throw error;
       }
 
       const comments = getGalleryComments(gallery.uri, ctx);

src/routes/actions.tsx

···
 import { Record as BskyFollow } from "$lexicon/types/app/bsky/graph/follow.ts";
 import { Record as Profile } from "$lexicon/types/social/grain/actor/profile.ts";
 import { Record as Favorite } from "$lexicon/types/social/grain/favorite.ts";
-import { Record as Gallery } from "$lexicon/types/social/grain/gallery.ts";
 import { GalleryView } from "$lexicon/types/social/grain/gallery/defs.ts";
 import { Record as GalleryItem } from "$lexicon/types/social/grain/gallery/item.ts";
 import { Record as Photo } from "$lexicon/types/social/grain/photo.ts";
 import { isPhotoView } from "$lexicon/types/social/grain/photo/defs.ts";
 import { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
-import { Facet } from "@atproto/api";
 import { AtUri } from "@atproto/syntax";
 import { BffContext, RouteHandler, WithBffMeta } from "@bigmoves/bff";
 import {
···
 import { PhotoPreview } from "../components/PhotoPreview.tsx";
 import { PhotoSelectButton } from "../components/PhotoSelectButton.tsx";
 import { getActorPhotos } from "../lib/actor.ts";
-import { getFollowers } from "../lib/follow.ts";
-import { deleteGallery, getGallery, getGalleryFav } from "../lib/gallery.ts";
-import { getPhoto, photoToView } from "../lib/photo.ts";
-import { parseFacetedText } from "../lib/rich_text.ts";
+import {
+  createGallery,
+  createGalleryItem,
+  deleteGallery,
+  getGallery,
+  getGalleryFav,
+  updateGallery,
+} from "../lib/gallery.ts";
+import { getFollowers } from "../lib/graph.ts";
+import { createExif, createPhoto, getPhoto } from "../lib/photo.ts";
 import type { State } from "../state.ts";
 import { galleryLink, profileLink, uploadPageLink } from "../utils.ts";
 
···
   const searchParams = new URLSearchParams(url.search);
   const uri = searchParams.get("uri");
 
-  let facets: Facet[] | undefined = undefined;
-  if (description) {
-    try {
-      const resp = parseFacetedText(description, ctx);
-      facets = resp.facets;
-    } catch (e) {
-      console.error("Failed to parse facets:", e);
-    }
-  }
-
   if (uri) {
-    const gallery = ctx.indexService.getRecord<WithBffMeta<Gallery>>(uri);
-    if (!gallery) return ctx.next();
+    const success = await updateGallery(ctx, uri, {
+      title,
+      description,
+    });
+    if (!success) {
+      return new Response("Failed to update gallery", { status: 500 });
+    }
     const rkey = new AtUri(uri).rkey;
-    try {
-      await ctx.updateRecord<Gallery>("social.grain.gallery", rkey, {
-        title,
-        description,
-        facets,
-        updatedAt: new Date().toISOString(),
-        createdAt: gallery.createdAt,
-      });
-    } catch (e) {
-      console.error("Error updating record:", e);
-      const errorMessage = e instanceof Error
-        ? e.message
-        : "Unknown error occurred";
-      return new Response(errorMessage, { status: 400 });
-    }
     return ctx.redirect(galleryLink(handle, rkey));
   }
 
-  const createdUri = await ctx.createRecord<Gallery>(
-    "social.grain.gallery",
-    {
-      title,
-      description,
-      facets,
-      updatedAt: new Date().toISOString(),
-      createdAt: new Date().toISOString(),
-    },
-  );
-  return ctx.redirect(galleryLink(handle, new AtUri(createdUri).rkey));
+  const galleryUri = await createGallery(ctx, { title, description });
+  if (!galleryUri) {
+    return new Response("Failed to create gallery", { status: 500 });
+  }
+  const rkey = new AtUri(galleryUri).rkey;
+  return ctx.redirect(galleryLink(handle, rkey));
 };
 
 export const galleryDelete: RouteHandler = async (
···
 
     const blobResponse = await ctx.agent.uploadBlob(file);
 
-    const photoUri = await ctx.createRecord<Photo>("social.grain.photo", {
+    const photoUri = await createPhoto({
       photo: blobResponse.data.blob,
       aspectRatio: width && height
         ? {
···
         : undefined,
       alt: "",
       createdAt: new Date().toISOString(),
-    });
+    }, ctx);
 
-    let exifUri: string | undefined = undefined;
     if (exif) {
-      exifUri = await ctx.createRecord<PhotoExif>(
-        "social.grain.photo.exif",
+      await createExif(
         {
           photo: photoUri,
+          ...exif,
           createdAt: new Date().toISOString(),
-          ...exif,
         },
+        ctx,
       );
     }
 
-    const photo = ctx.indexService.getRecord<WithBffMeta<Photo>>(photoUri);
-    if (!photo) {
-      return new Response("Photo not found after creation", { status: 404 });
-    }
-
     let gallery: GalleryView | undefined = undefined;
     if (galleryUri) {
       gallery = getGallery(did, new AtUri(galleryUri).rkey, ctx) ?? undefined;
-      if (gallery) {
-        await ctx.createRecord<GalleryItem>("social.grain.gallery.item", {
-          gallery: galleryUri,
-          item: photoUri,
-          position: gallery.items?.length ?? 0,
-          createdAt: new Date().toISOString(),
-        });
-      }
+      await createGalleryItem(ctx, galleryUri, photoUri);
     }
 
-    let exifRecord: WithBffMeta<PhotoExif> | undefined = undefined;
-    if (exifUri) {
-      exifRecord = ctx.indexService.getRecord<WithBffMeta<PhotoExif>>(
-        exifUri,
-      );
-    }
+    const photo = getPhoto(photoUri, ctx);
+    if (!photo) return ctx.next();
 
     if (page === "gallery" && gallery && galleryUri) {
       const rkey = new AtUri(gallery.uri).rkey;
···
       if (!updatedGallery) {
         return ctx.next();
       }
-      const p = photoToView(did, photo, exifRecord);
       return ctx.html(
         <>
           <PhotoSelectButton
             galleryUri={gallery.uri}
-            photo={p}
+            photo={photo}
           />
           <div hx-swap-oob="beforeend:#gallery-container">
             <GalleryLayout.Item
               key={photo.cid}
-              photo={p}
+              photo={photo}
               gallery={updatedGallery}
             />
           </div>
···
     return ctx.html(
       <>
         <PhotoPreview
-          photo={photoToView(did, photo, exifRecord)}
+          photo={photo}
           selectedGallery={gallery}
         />
         <div hx-swap-oob="photos-count">{photosCount}</div>
       </>,
     );
   } catch (e) {
-    console.error("Error in uploadStart:", e);
+    console.error("Error in uploadPhoto:", e);
     return new Response("Internal Server Error", { status: 500 });
   }
 };

src/routes/followers.tsx

···
 import { FollowsList } from "../components/FollowsList.tsx";
 import { Header } from "../components/Header.tsx";
 import { getActorProfile } from "../lib/actor.ts";
-import { getFollowersWithProfiles } from "../lib/follow.ts";
+import { getFollowersWithProfiles } from "../lib/graph.ts";
 import { State } from "../state.ts";
 import { profileLink } from "../utils.ts";
 

src/routes/follows.tsx

···
 import { FollowsList } from "../components/FollowsList.tsx";
 import { Header } from "../components/Header.tsx";
 import { getActorProfile } from "../lib/actor.ts";
-import { getFollowingWithProfiles } from "../lib/follow.ts";
+import { getFollowingWithProfiles } from "../lib/graph.ts";
 import { State } from "../state.ts";
 import { profileLink } from "../utils.ts";