feat: start working on xrpc routes

__generated__/index.ts

···
   type StreamAuthVerifier,
 } from "npm:@atproto/xrpc-server"
 import { schemas } from './lexicons.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 SocialGrainFeedGetTimeline from './types/social/grain/feed/getTimeline.ts'
+import * as SocialGrainActorGetProfile from './types/social/grain/actor/getProfile.ts'
 
 export const APP_BSKY_GRAPH = {
   DefsModlist: 'app.bsky.graph.defs#modlist',
···
   gallery: SocialGrainGalleryNS
   graph: SocialGrainGraphNS
   labeler: SocialGrainLabelerNS
+  feed: SocialGrainFeedNS
   actor: SocialGrainActorNS
   photo: SocialGrainPhotoNS
 
···
     this.gallery = new SocialGrainGalleryNS(server)
     this.graph = new SocialGrainGraphNS(server)
     this.labeler = new SocialGrainLabelerNS(server)
+    this.feed = new SocialGrainFeedNS(server)
     this.actor = new SocialGrainActorNS(server)
     this.photo = new SocialGrainPhotoNS(server)
   }
···
   constructor(server: Server) {
     this._server = server
   }
+
+  getGalleryThread<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryGetGalleryThread.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryGetGalleryThread.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.getGalleryThread' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getActorGalleries<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryGetActorGalleries.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryGetActorGalleries.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.getActorGalleries' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getGallery<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainGalleryGetGallery.Handler<ExtractAuth<AV>>,
+      SocialGrainGalleryGetGallery.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.gallery.getGallery' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
 }
 
 export class SocialGrainGraphNS {
···
   }
 }
 
+export class SocialGrainFeedNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getTimeline<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainFeedGetTimeline.Handler<ExtractAuth<AV>>,
+      SocialGrainFeedGetTimeline.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.feed.getTimeline' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
 export class SocialGrainActorNS {
   _server: Server
 
   constructor(server: Server) {
     this._server = server
+  }
+
+  getProfile<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      SocialGrainActorGetProfile.Handler<ExtractAuth<AV>>,
+      SocialGrainActorGetProfile.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'social.grain.actor.getProfile' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
   }
 }
 

__generated__/lexicons.ts

···
       },
     },
   },
+  SocialGrainGalleryGetGalleryThread: {
+    lexicon: 1,
+    id: 'social.grain.gallery.getGalleryThread',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Gets a hydrated gallery view and its comments for a specified gallery AT-URI.',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description:
+                'The AT-URI of the gallery to return a hydrated view and comments for.',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['gallery', 'comments'],
+            properties: {
+              gallery: {
+                type: 'ref',
+                ref: 'lex:social.grain.gallery.defs#galleryView',
+              },
+              comments: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.comment.defs#commentView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  SocialGrainGalleryGetActorGalleries: {
+    lexicon: 1,
+    id: 'social.grain.gallery.getActorGalleries',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          "Get a view of an actor's galleries. Does not require auth.",
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['items'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              items: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.gallery.defs#galleryView',
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'BlockedActor',
+          },
+          {
+            name: 'BlockedByActor',
+          },
+        ],
+      },
+    },
+  },
+  SocialGrainGalleryGetGallery: {
+    lexicon: 1,
+    id: 'social.grain.gallery.getGallery',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Gets a hydrated gallery view for a specified gallery AT-URI.',
+        parameters: {
+          type: 'params',
+          required: ['uri'],
+          properties: {
+            uri: {
+              type: 'string',
+              description:
+                'The AT-URI of the gallery to return a hydrated view for.',
+              format: 'at-uri',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:social.grain.gallery.defs#galleryView',
+          },
+        },
+      },
+    },
+  },
   SocialGrainGraphFollow: {
     lexicon: 1,
     id: 'social.grain.graph.follow',
···
       },
     },
   },
+  SocialGrainFeedGetTimeline: {
+    lexicon: 1,
+    id: 'social.grain.feed.getTimeline',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get a view of the requesting account's home timeline.",
+        parameters: {
+          type: 'params',
+          properties: {
+            algorithm: {
+              type: 'string',
+              description:
+                "Variant 'algorithm' for timeline. Implementation-specific.",
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['feed'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              feed: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:social.grain.gallery.defs#galleryView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   SocialGrainFavorite: {
     lexicon: 1,
     id: 'social.grain.favorite',
···
           createdAt: {
             type: 'string',
             format: 'datetime',
+          },
+        },
+      },
+      profileViewDetailed: {
+        type: 'object',
+        required: ['did', 'handle'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          handle: {
+            type: 'string',
+            format: 'handle',
+          },
+          displayName: {
+            type: 'string',
+            maxGraphemes: 64,
+            maxLength: 640,
+          },
+          description: {
+            type: 'string',
+            maxGraphemes: 256,
+            maxLength: 2560,
+          },
+          avatar: {
+            type: 'string',
+            format: 'uri',
+          },
+          followersCount: {
+            type: 'integer',
+          },
+          followsCount: {
+            type: 'integer',
+          },
+          galleryCount: {
+            type: 'integer',
+          },
+          indexedAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          viewer: {
+            type: 'ref',
+            ref: 'lex:social.grain.actor.defs#viewerState',
+          },
+          labels: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#label',
+            },
+          },
+        },
+      },
+      viewerState: {
+        type: 'object',
+        description:
+          "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.",
+        properties: {
+          following: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          followedBy: {
+            type: 'string',
+            format: 'at-uri',
+          },
+        },
+      },
+    },
+  },
+  SocialGrainActorGetProfile: {
+    lexicon: 1,
+    id: 'social.grain.actor.getProfile',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.',
+        parameters: {
+          type: 'params',
+          required: ['actor'],
+          properties: {
+            actor: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'Handle or DID of account to fetch profile of.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'ref',
+            ref: 'lex:social.grain.actor.defs#profileViewDetailed',
           },
         },
       },
···
   SocialGrainGalleryItem: 'social.grain.gallery.item',
   SocialGrainGalleryDefs: 'social.grain.gallery.defs',
   SocialGrainGallery: 'social.grain.gallery',
+  SocialGrainGalleryGetGalleryThread: 'social.grain.gallery.getGalleryThread',
+  SocialGrainGalleryGetActorGalleries: 'social.grain.gallery.getActorGalleries',
+  SocialGrainGalleryGetGallery: 'social.grain.gallery.getGallery',
   SocialGrainGraphFollow: 'social.grain.graph.follow',
   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',
   SocialGrainActorProfile: 'social.grain.actor.profile',
   SocialGrainPhotoDefs: 'social.grain.photo.defs',
   SocialGrainPhotoExif: 'social.grain.photo.exif',

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

···
 export function validateProfileView<V>(v: V) {
   return validate<ProfileView & V>(v, id, hashProfileView)
 }
+
+export interface ProfileViewDetailed {
+  $type?: 'social.grain.actor.defs#profileViewDetailed'
+  did: string
+  handle: string
+  displayName?: string
+  description?: string
+  avatar?: string
+  followersCount?: number
+  followsCount?: number
+  galleryCount?: number
+  indexedAt?: string
+  createdAt?: string
+  viewer?: ViewerState
+  labels?: ComAtprotoLabelDefs.Label[]
+}
+
+const hashProfileViewDetailed = 'profileViewDetailed'
+
+export function isProfileViewDetailed<V>(v: V) {
+  return is$typed(v, id, hashProfileViewDetailed)
+}
+
+export function validateProfileViewDetailed<V>(v: V) {
+  return validate<ProfileViewDetailed & V>(v, id, hashProfileViewDetailed)
+}
+
+/** Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests. */
+export interface ViewerState {
+  $type?: 'social.grain.actor.defs#viewerState'
+  following?: string
+  followedBy?: string
+}
+
+const hashViewerState = 'viewerState'
+
+export function isViewerState<V>(v: V) {
+  return is$typed(v, id, hashViewerState)
+}
+
+export function validateViewerState<V>(v: V) {
+  return validate<ViewerState & V>(v, id, hashViewerState)
+}

__generated__/types/social/grain/actor/getProfile.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";
+import type * as SocialGrainActorDefs from "./defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.actor.getProfile";
+
+export interface QueryParams {
+  /** Handle or DID of account to fetch profile of. */
+  actor: string;
+}
+
+export type InputSchema = undefined;
+export type OutputSchema = SocialGrainActorDefs.ProfileViewDetailed;
+export type HandlerInput = undefined;
+
+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/feed/getTimeline.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";
+import type * as SocialGrainGalleryDefs from "../gallery/defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.feed.getTimeline";
+
+export interface QueryParams {
+  /** Variant 'algorithm' for timeline. Implementation-specific. */
+  algorithm?: string;
+  limit: number;
+  cursor?: string;
+}
+
+export type InputSchema = undefined;
+
+export interface OutputSchema {
+  cursor?: string;
+  feed: SocialGrainGalleryDefs.GalleryView[];
+}
+
+export type HandlerInput = undefined;
+
+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/getActorGalleries.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";
+import type * as SocialGrainGalleryDefs from "./defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.getActorGalleries";
+
+export interface QueryParams {
+  actor: string;
+  limit: number;
+  cursor?: string;
+}
+
+export type InputSchema = undefined;
+
+export interface OutputSchema {
+  cursor?: string;
+  items: SocialGrainGalleryDefs.GalleryView[];
+}
+
+export type HandlerInput = undefined;
+
+export interface HandlerSuccess {
+  encoding: "application/json";
+  body: OutputSchema;
+  headers?: { [key: string]: string };
+}
+
+export interface HandlerError {
+  status: number;
+  message?: string;
+  error?: "BlockedActor" | "BlockedByActor";
+}
+
+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/getGallery.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";
+import type * as SocialGrainGalleryDefs from "./defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.getGallery";
+
+export interface QueryParams {
+  /** The AT-URI of the gallery to return a hydrated view for. */
+  uri: string;
+}
+
+export type InputSchema = undefined;
+export type OutputSchema = SocialGrainGalleryDefs.GalleryView;
+export type HandlerInput = undefined;
+
+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/getGalleryThread.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";
+import type * as SocialGrainCommentDefs from "../comment/defs.ts";
+import type * as SocialGrainGalleryDefs from "./defs.ts";
+
+const is$typed = _is$typed,
+  validate = _validate;
+const id = "social.grain.gallery.getGalleryThread";
+
+export interface QueryParams {
+  /** The AT-URI of the gallery to return a hydrated view and comments for. */
+  uri: string;
+}
+
+export type InputSchema = undefined;
+
+export interface OutputSchema {
+  gallery: SocialGrainGalleryDefs.GalleryView;
+  comments: SocialGrainCommentDefs.CommentView[];
+}
+
+export type HandlerInput = undefined;
+
+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.41",
+    "@bigmoves/bff": "jsr:@bigmoves/bff@0.3.0-beta.42",
     "@std/http": "jsr:@std/http@^1.0.17",
     "@std/path": "jsr:@std/path@^1.0.9",
     "@tailwindcss/cli": "npm:@tailwindcss/cli@^4.1.4",

deno.lock

···
   "version": "5",
   "specifiers": {
     "jsr:@bigmoves/atproto-oauth-client@0.2": "0.2.0",
-    "jsr:@bigmoves/bff@0.3.0-beta.41": "0.3.0-beta.41",
+    "jsr:@bigmoves/bff@0.3.0-beta.42": "0.3.0-beta.42",
     "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",
···
     "npm:@atproto/oauth-client@~0.3.13": "0.3.22",
     "npm:@atproto/oauth-types@~0.2.4": "0.2.8",
     "npm:@atproto/syntax@0.4": "0.4.0",
-    "npm:@atproto/xrpc-server@*": "0.7.19",
+    "npm:@atproto/xrpc-server@*": "0.7.18",
     "npm:@atproto/xrpc-server@0.7.18": "0.7.18",
     "npm:@atproto/xrpc-server@0.7.19": "0.7.19",
     "npm:@tailwindcss/cli@*": "4.1.9",
···
     "npm:date-fns@^4.1.0": "4.1.0",
     "npm:esbuild@~0.25.5": "0.25.5",
     "npm:exifr@^7.1.3": "7.1.3",
+    "npm:express@*": "4.21.2",
     "npm:github-slugger@2": "2.0.0",
     "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:jose@5.9.6": "5.9.6",
+    "npm:jsonwebtoken@^9.0.2": "9.0.2",
     "npm:katex@0.16": "0.16.22",
     "npm:marked-alert@2": "2.1.2_marked@12.0.2",
     "npm:marked-footnote@^1.2.0": "1.2.4_marked@12.0.2",
···
         "npm:jose"
       ]
     },
-    "@bigmoves/bff@0.3.0-beta.41": {
-      "integrity": "141414a26dcb44d6a08a8a259011e0a7ef01b104ff5664dafc380a6f0f9a22c0",
+    "@bigmoves/bff@0.3.0-beta.42": {
+      "integrity": "4866ae7f9e1a61e0abe8255f40e6ccba6d370a0ea4710cf061ebfcb5248ac688",
       "dependencies": [
         "jsr:@bigmoves/atproto-oauth-client",
         "jsr:@std/assert@^1.0.13",
···
         "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",
···
         "fill-range"
       ]
     },
+    "buffer-equal-constant-time@1.0.1": {
+      "integrity": "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="
+    },
     "buffer-from@1.1.2": {
       "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ=="
     },
···
         "call-bind-apply-helpers",
         "es-errors",
         "gopd"
+      ]
+    },
+    "ecdsa-sig-formatter@1.0.11": {
+      "integrity": "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ==",
+      "dependencies": [
+        "safe-buffer"
       ]
     },
     "ee-first@1.1.1": {
···
     "jose@5.9.6": {
       "integrity": "sha512-AMlnetc9+CV9asI19zHmrgS/WYsWUwCn2R7RzlbJWD7F9eWYUTGyBmU9o6PxngtLGOiDGPRu+Uc4fhKzbpteZQ=="
     },
+    "jsonwebtoken@9.0.2": {
+      "integrity": "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ==",
+      "dependencies": [
+        "jws",
+        "lodash.includes",
+        "lodash.isboolean",
+        "lodash.isinteger",
+        "lodash.isnumber",
+        "lodash.isplainobject",
+        "lodash.isstring",
+        "lodash.once",
+        "ms@2.1.3",
+        "semver"
+      ]
+    },
+    "jwa@1.4.2": {
+      "integrity": "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw==",
+      "dependencies": [
+        "buffer-equal-constant-time",
+        "ecdsa-sig-formatter",
+        "safe-buffer"
+      ]
+    },
+    "jws@3.2.2": {
+      "integrity": "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA==",
+      "dependencies": [
+        "jwa",
+        "safe-buffer"
+      ]
+    },
     "katex@0.16.22": {
       "integrity": "sha512-XCHRdUw4lf3SKBaJe4EvgqIuWwkPSo9XoeO8GjQW94Bp7TWv9hNhzZjZ+OH9yf1UmLygb7DIT5GSFQiyt16zYg==",
       "dependencies": [
···
         "lightningcss-win32-x64-msvc"
       ]
     },
+    "lodash.includes@4.3.0": {
+      "integrity": "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="
+    },
+    "lodash.isboolean@3.0.3": {
+      "integrity": "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg=="
+    },
+    "lodash.isinteger@4.0.4": {
+      "integrity": "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA=="
+    },
+    "lodash.isnumber@3.0.3": {
+      "integrity": "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw=="
+    },
+    "lodash.isplainobject@4.0.6": {
+      "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="
+    },
+    "lodash.isstring@4.0.1": {
+      "integrity": "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="
+    },
+    "lodash.once@4.1.1": {
+      "integrity": "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg=="
+    },
     "lru-cache@10.4.3": {
       "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ=="
     },
···
         "postcss"
       ]
     },
+    "semver@7.7.2": {
+      "integrity": "sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==",
+      "bin": true
+    },
     "send@0.19.0": {
       "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
       "dependencies": [
···
   },
   "workspace": {
     "dependencies": [
-      "jsr:@bigmoves/bff@0.3.0-beta.41",
+      "jsr:@bigmoves/bff@0.3.0-beta.42",
       "jsr:@std/http@^1.0.17",
       "jsr:@std/path@^1.0.9",
       "npm:@atproto/api@~0.15.16",

lexicons/social/grain/actor/defs.json

···
         "avatar": { "type": "string", "format": "uri" },
         "createdAt": { "type": "string", "format": "datetime" }
       }
+    },
+    "profileViewDetailed": {
+      "type": "object",
+      "required": ["did", "handle"],
+      "properties": {
+        "did": { "type": "string", "format": "did" },
+        "handle": { "type": "string", "format": "handle" },
+        "displayName": {
+          "type": "string",
+          "maxGraphemes": 64,
+          "maxLength": 640
+        },
+        "description": {
+          "type": "string",
+          "maxGraphemes": 256,
+          "maxLength": 2560
+        },
+        "avatar": { "type": "string", "format": "uri" },
+        "followersCount": { "type": "integer" },
+        "followsCount": { "type": "integer" },
+        "galleryCount": { "type": "integer" },
+        "indexedAt": { "type": "string", "format": "datetime" },
+        "createdAt": { "type": "string", "format": "datetime" },
+        "viewer": { "type": "ref", "ref": "#viewerState" },
+        "labels": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "com.atproto.label.defs#label" }
+        }
+      }
+    },
+    "viewerState": {
+      "type": "object",
+      "description": "Metadata about the requesting account's relationship with the subject account. Only has meaningful content for authed requests.",
+      "properties": {
+        "following": { "type": "string", "format": "at-uri" },
+        "followedBy": { "type": "string", "format": "at-uri" }
+      }
     }
   }
 }

lexicons/social/grain/actor/getProfile.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.actor.getProfile",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get detailed profile view of an actor. Does not require auth, but contains relevant metadata with auth.",
+      "parameters": {
+        "type": "params",
+        "required": ["actor"],
+        "properties": {
+          "actor": {
+            "type": "string",
+            "format": "at-identifier",
+            "description": "Handle or DID of account to fetch profile of."
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "social.grain.actor.defs#profileViewDetailed"
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/feed/getTimeline.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.feed.getTimeline",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a view of the requesting account's home timeline.",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "algorithm": {
+            "type": "string",
+            "description": "Variant 'algorithm' for timeline. Implementation-specific."
+          },
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100,
+            "default": 50
+          },
+          "cursor": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["feed"],
+          "properties": {
+            "cursor": { "type": "string" },
+            "feed": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "social.grain.gallery.defs#galleryView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/getActorGalleries.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.getActorGalleries",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a view of an actor's galleries. Does not require auth.",
+      "parameters": {
+        "type": "params",
+        "required": ["actor"],
+        "properties": {
+          "actor": { "type": "string", "format": "at-identifier" },
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100,
+            "default": 50
+          },
+          "cursor": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["items"],
+          "properties": {
+            "cursor": { "type": "string" },
+            "items": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "social.grain.gallery.defs#galleryView"
+              }
+            }
+          }
+        }
+      },
+      "errors": [{ "name": "BlockedActor" }, { "name": "BlockedByActor" }]
+    }
+  }
+}

lexicons/social/grain/gallery/getGallery.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.getGallery",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Gets a hydrated gallery view for a specified gallery AT-URI.",
+      "parameters": {
+        "type": "params",
+        "required": ["uri"],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The AT-URI of the gallery to return a hydrated view for.",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "ref",
+          "ref": "social.grain.gallery.defs#galleryView"
+        }
+      }
+    }
+  }
+}

lexicons/social/grain/gallery/getGalleryThread.json

···
+{
+  "lexicon": 1,
+  "id": "social.grain.gallery.getGalleryThread",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Gets a hydrated gallery view and its comments for a specified gallery AT-URI.",
+      "parameters": {
+        "type": "params",
+        "required": ["uri"],
+        "properties": {
+          "uri": {
+            "type": "string",
+            "description": "The AT-URI of the gallery to return a hydrated view and comments for.",
+            "format": "at-uri"
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["gallery", "comments"],
+          "properties": {
+            "gallery": {
+              "type": "ref",
+              "ref": "social.grain.gallery.defs#galleryView"
+            },
+            "comments": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "social.grain.comment.defs#commentView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

src/api/mod.ts

···
+import {
+  OutputSchema as GetProfileOutputSchema,
+  QueryParams as GetProfileQueryParams,
+} from "$lexicon/types/social/grain/actor/getProfile.ts";
+import {
+  OutputSchema as GetTimelineOutputSchema,
+} from "$lexicon/types/social/grain/feed/getTimeline.ts";
+import {
+  OutputSchema as GetActorGalleriesOutputSchema,
+  QueryParams as GetActorGalleriesQueryParams,
+} from "$lexicon/types/social/grain/gallery/getActorGalleries.ts";
+import {
+  OutputSchema as GetGalleryOutputSchema,
+  QueryParams as GetGalleryQueryParams,
+} from "$lexicon/types/social/grain/gallery/getGallery.ts";
+import {
+  OutputSchema as GetGalleryThreadOutputSchema,
+  QueryParams as GetGalleryThreadQueryParams,
+} from "$lexicon/types/social/grain/gallery/getGalleryThread.ts";
+import { AtUri } from "@atproto/syntax";
+import { BffMiddleware, OAUTH_ROUTES, route } from "@bigmoves/bff";
+import { getActorGalleries, getActorProfileDetailed } from "../lib/actor.ts";
+import { BadRequestError } from "../lib/errors.ts";
+import { getGallery } from "../lib/gallery.ts";
+import { getTimeline } from "../lib/timeline.ts";
+import { getGalleryComments } from "../modules/comments.tsx";
+
+export const middlewares: BffMiddleware[] = [
+  async (req, ctx) => {
+    const url = new URL(req.url);
+    const { pathname } = url;
+
+    if (pathname === OAUTH_ROUTES.tokenCallback) {
+      const token = url.searchParams.get("token") ?? undefined;
+      if (!token) {
+        throw new BadRequestError("Missing token parameter");
+      }
+      return ctx.redirect(`grainflutter://auth/callback?token=${token}`);
+    }
+
+    return ctx.next();
+  },
+  route("/oauth/session", (_req, _params, ctx) => {
+    if (!ctx.currentUser) {
+      return ctx.json("Unauthorized", 401);
+    }
+    const did = ctx.currentUser.did;
+    const profile = getActorProfileDetailed(did, ctx);
+    if (!profile) {
+      return ctx.json("Profile not found", 404);
+    }
+    return ctx.json(profile);
+  }),
+  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);
+  }),
+  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);
+  }),
+  route("/xrpc/social.grain.gallery.getGallery", (req, _params, ctx) => {
+    const url = new URL(req.url);
+    const { uri } = getGalleryQueryParams(url);
+    const atUri = new AtUri(uri);
+    const did = atUri.hostname;
+    const rkey = atUri.rkey;
+    const gallery = getGallery(did, rkey, ctx);
+    if (!gallery) {
+      return ctx.json("Gallery not found", 404);
+    }
+    return ctx.json(gallery as GetGalleryOutputSchema);
+  }),
+  route("/xrpc/social.grain.gallery.getGalleryThread", (req, _params, ctx) => {
+    const url = new URL(req.url);
+    const { uri } = getGalleryThreadQueryParams(url);
+    const atUri = new AtUri(uri);
+    const did = atUri.hostname;
+    const rkey = atUri.rkey;
+    const gallery = getGallery(did, rkey, ctx);
+    if (!gallery) {
+      return ctx.json("Gallery not found", 404);
+    }
+    const comments = getGalleryComments(uri, ctx);
+    return ctx.json({ gallery, comments } as GetGalleryThreadOutputSchema);
+  }),
+  route("/xrpc/social.grain.feed.getTimeline", async (_req, _params, ctx) => {
+    // const url = new URL(req.url);
+    // const { algorithm, limit, cursor } = getTimelineQueryParams(url);
+    const items = await getTimeline(
+      ctx,
+      "timeline",
+      "grain",
+    );
+    return ctx.json(
+      { feed: items.map((i) => i.gallery) } as GetTimelineOutputSchema,
+    );
+  }),
+];
+
+function getProfileQueryParams(url: URL): GetProfileQueryParams {
+  const actor = url.searchParams.get("actor");
+  if (!actor) throw new BadRequestError("Missing actor parameter");
+  return { actor };
+}
+
+function getActorGalleriesQueryParams(url: URL): GetActorGalleriesQueryParams {
+  const actor = url.searchParams.get("actor");
+  if (!actor) throw new BadRequestError("Missing actor parameter");
+  const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+  if (isNaN(limit) || limit <= 0) {
+    throw new BadRequestError("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");
+  return { uri };
+}
+
+function getGalleryThreadQueryParams(url: URL): GetGalleryThreadQueryParams {
+  const uri = url.searchParams.get("uri");
+  if (!uri) throw new BadRequestError("Missing uri parameter");
+  return { uri };
+}
+
+// function getTimelineQueryParams(url: URL): GetTimelineQueryParams {
+//   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");
+//   }
+//   const cursor = url.searchParams.get("cursor") ?? undefined;
+//   return { algorithm, limit, cursor };
+// }

src/lib/actor.ts

···
 import { Record as BskyProfile } from "$lexicon/types/app/bsky/actor/profile.ts";
 import { Label } from "$lexicon/types/com/atproto/label/defs.ts";
 import { Record as TangledProfile } from "$lexicon/types/sh/tangled/actor/profile.ts";
-import { ProfileView } from "$lexicon/types/social/grain/actor/defs.ts";
+import {
+  ProfileView,
+  ProfileViewDetailed,
+} from "$lexicon/types/social/grain/actor/defs.ts";
 import { Record as GrainProfile } 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 { Record as PhotoExif } from "$lexicon/types/social/grain/photo/exif.ts";
 import { Un$Typed } from "$lexicon/util.ts";
 import { BffContext, WithBffMeta } from "@bigmoves/bff";
-import { galleryToView, getGalleryItemsAndPhotos } from "./gallery.ts";
+import { getFollowersCount, getFollowsCount } from "./follow.ts";
+import {
+  galleryToView,
+  getGalleryCount,
+  getGalleryItemsAndPhotos,
+} from "./gallery.ts";
 import { photoToView, photoUrl } from "./photo.ts";
 import type { SocialNetwork } from "./timeline.ts";
 
···
   return profileRecord ? profileToView(profileRecord, actor.handle) : null;
 }
 
+export function getActorProfileDetailed(did: string, ctx: BffContext) {
+  const actor = ctx.indexService.getActor(did);
+  if (!actor) return null;
+  const profileRecord = ctx.indexService.getRecord<WithBffMeta<GrainProfile>>(
+    `at://${did}/social.grain.actor.profile/self`,
+  );
+  const followersCount = getFollowersCount(did, ctx);
+  const followsCount = getFollowsCount(did, ctx);
+  const galleryCount = getGalleryCount(did, ctx);
+  return profileRecord
+    ? profileDetailedToView(
+      profileRecord,
+      actor.handle,
+      followersCount,
+      followsCount,
+      galleryCount,
+    )
+    : null;
+}
+
 export function profileToView(
   record: WithBffMeta<GrainProfile>,
   handle: string,
···
     avatar: record?.avatar
       ? photoUrl(record.did, record.avatar.ref.toString(), "thumbnail")
       : undefined,
+  };
+}
+
+export function profileDetailedToView(
+  record: WithBffMeta<GrainProfile>,
+  handle: string,
+  followersCount: number,
+  followsCount: number,
+  galleryCount: number,
+): Un$Typed<ProfileViewDetailed> {
+  return {
+    did: record.did,
+    handle,
+    displayName: record.displayName,
+    description: record.description,
+    avatar: record?.avatar
+      ? photoUrl(record.did, record.avatar.ref.toString(), "thumbnail")
+      : undefined,
+    followersCount,
+    followsCount,
+    galleryCount,
   };
 }
 

src/lib/follow.ts

···
       profile != null
     );
 }
+
+export function getFollowersCount(
+  followeeDid: string,
+  ctx: BffContext,
+): number {
+  return ctx.indexService.countRecords(
+    "social.grain.graph.follow",
+    {
+      orderBy: [{ field: "createdAt", direction: "desc" }],
+      where: [{
+        field: "subject",
+        equals: followeeDid,
+      }],
+    },
+  );
+}
+
+export function getFollowsCount(
+  followerDid: string,
+  ctx: BffContext,
+): number {
+  return ctx.indexService.countRecords(
+    "social.grain.graph.follow",
+    {
+      orderBy: [{ field: "createdAt", direction: "desc" }],
+      where: [{
+        field: "did",
+        equals: followerDid,
+      }],
+    },
+  );
+}

src/lib/gallery.ts

···
     })
     .filter((g): g is ReturnType<typeof galleryToView> => g !== null);
 }
+
+export function getGalleryCount(
+  userDid: string,
+  ctx: BffContext,
+): number {
+  return ctx.indexService.countRecords("social.grain.gallery", {
+    where: [{ field: "did", equals: userDid }],
+  });
+}

src/main.tsx

···
 import { lexicons } from "$lexicon/lexicons.ts";
 import { bff, oauth, route } from "@bigmoves/bff";
+import { middlewares as xrpcApi } from "./api/mod.ts";
 import { Root } from "./app.tsx";
 import { LoginPage } from "./components/LoginPage.tsx";
 import { PDS_HOST_URL } from "./env.ts";
···
   rootElement: Root,
   onError,
   middlewares: [
+    ...xrpcApi,
     appStateMiddleware,
     oauth({
       onSignedIn,

src/modules/comments.tsx

···
   }, []);
 }
 
-function getGalleryComments(uri: string, ctx: BffContext): CommentView[] {
+export function getGalleryComments(
+  uri: string,
+  ctx: BffContext,
+): CommentView[] {
   const { items: comments } = ctx.indexService.getRecords<WithBffMeta<Comment>>(
     "social.grain.comment",
     {