use xrpc

README.md

···
 
 The backend server will:
 
-- Serve the API at `/api/*` endpoints
+- Serve the API at `/xrpc/*` and `/oauth/*` endpoints
 - Serve the frontend static files from the client's build directory
 - Handle client-side routing by serving index.html for all non-API routes
 

lexicons/xyz/statusphere/getStatuses.json

···
+{
+  "lexicon": 1,
+  "id": "xyz.statusphere.getStatuses",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get a list of the most recent statuses on the network.",
+      "parameters": {
+        "type": "params",
+        "properties": {
+          "limit": {
+            "type": "integer",
+            "minimum": 1,
+            "maximum": 100,
+            "default": 50
+          },
+          "cursor": { "type": "string" }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["statuses"],
+          "properties": {
+            "cursor": { "type": "string" },
+            "statuses": {
+              "type": "array",
+              "items": {
+                "type": "ref",
+                "ref": "xyz.statusphere.defs#statusView"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/xyz/statusphere/getUser.json

···
+{
+  "lexicon": 1,
+  "id": "xyz.statusphere.getUser",
+  "defs": {
+    "main": {
+      "type": "query",
+      "description": "Get the current user's profile and status.",
+      "parameters": {
+        "type": "params",
+        "properties": {}
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["profile"],
+          "properties": {
+            "profile": {
+              "type": "ref",
+              "ref": "app.bsky.actor.defs#profileView"
+            },
+            "status": {
+              "type": "ref",
+              "ref": "xyz.statusphere.defs#statusView"
+            }
+          }
+        }
+      }
+    }
+  }
+}

lexicons/xyz/statusphere/sendStatus.json

···
+{
+  "lexicon": 1,
+  "id": "xyz.statusphere.sendStatus",
+  "defs": {
+    "main": {
+      "type": "procedure",
+      "description": "Send a status into the ATmosphere.",
+      "input": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["status"],
+          "properties": {
+            "status": {
+              "type": "string",
+              "minLength": 1,
+              "maxGraphemes": 1,
+              "maxLength": 32
+            }
+          }
+        }
+      },
+      "output": {
+        "encoding": "application/json",
+        "schema": {
+          "type": "object",
+          "required": ["status"],
+          "properties": {
+            "status": {
+              "type": "ref",
+              "ref": "xyz.statusphere.defs#statusView"
+            }
+          }
+        }
+      }
+    }
+  }
+}

package.json

···
     "dev:lexicon": "pnpm --filter @statusphere/lexicon dev",
     "dev:appview": "pnpm --filter @statusphere/appview dev",
     "dev:client": "pnpm --filter @statusphere/client dev",
-    "lexgen": "pnpm --filter @statusphere/lexicon lexgen",
+    "lexgen": "pnpm -r lexgen",
     "build": "pnpm build:lexicon && pnpm build:client && pnpm build:appview",
     "build:lexicon": "pnpm --filter @statusphere/lexicon build",
     "build:appview": "pnpm --filter @statusphere/appview build",

packages/appview/package.json

···
     "dev": "tsx watch --clear-screen=false src/index.ts | pino-pretty",
     "build": "tsup",
     "start": "node dist/index.js",
+    "lexgen": "lex gen-server ./src/lexicons ../../lexicons/xyz/statusphere/* ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/* --yes && pnpm format",
     "clean": "rimraf dist coverage",
     "format": "prettier --write src",
     "typecheck": "tsc --noEmit"
···
     "@atproto/xrpc-server": "^0.7.11",
     "@statusphere/lexicon": "workspace:*",
     "better-sqlite3": "^11.8.1",
+    "compression": "^1.8.0",
     "cors": "^2.8.5",
     "dotenv": "^16.4.7",
     "envalid": "^8.0.0",
···
     "pino": "^9.6.0"
   },
   "devDependencies": {
+    "@atproto/lex-cli": "^0.6.1",
     "@types/better-sqlite3": "^7.6.12",
+    "@types/compression": "^1.7.5",
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/node": "^22.13.8",

packages/appview/src/api/health.ts

···
+import { Router } from 'express'
+
+import { AppContext } from '#/context'
+
+export const createRouter = (ctx: AppContext) => {
+  const router = Router()
+
+  router.get('/health', async function (req, res) {
+    res.status(200).send('OK')
+  })
+
+  return router
+}

packages/appview/src/api/index.ts

···
+import { AppContext } from '#/context'
+import { Server } from '#/lexicons'
+import getStatuses from './lexicons/getStatuses'
+import getUser from './lexicons/getUser'
+import sendStatus from './lexicons/sendStatus'
+
+export * as health from './health'
+export * as oauth from './oauth'
+
+export default function (server: Server, ctx: AppContext) {
+  getStatuses(server, ctx)
+  sendStatus(server, ctx)
+  getUser(server, ctx)
+  return server
+}

packages/appview/src/api/lexicons/getStatuses.ts

···
+import { AppContext } from '#/context'
+import { Server } from '#/lexicons'
+import { statusToStatusView } from '#/lib/hydrate'
+
+export default function (server: Server, ctx: AppContext) {
+  server.xyz.statusphere.getStatuses({
+    handler: async ({ params }) => {
+      // Fetch data stored in our SQLite
+      const statuses = await ctx.db
+        .selectFrom('status')
+        .selectAll()
+        .orderBy('indexedAt', 'desc')
+        .limit(params.limit)
+        .execute()
+
+      return {
+        encoding: 'application/json',
+        body: {
+          statuses: await Promise.all(
+            statuses.map((status) => statusToStatusView(status, ctx)),
+          ),
+        },
+      }
+    },
+  })
+}

packages/appview/src/api/lexicons/getUser.ts

···
+import { AuthRequiredError } from '@atproto/xrpc-server'
+import { AppBskyActorProfile } from '@statusphere/lexicon'
+
+import { AppContext } from '#/context'
+import { Server } from '#/lexicons'
+import { bskyProfileToProfileView, statusToStatusView } from '#/lib/hydrate'
+import { getSessionAgent } from '#/session'
+
+export default function (server: Server, ctx: AppContext) {
+  server.xyz.statusphere.getUser({
+    handler: async ({ req, res }) => {
+      const agent = await getSessionAgent(req, res, ctx)
+      if (!agent) {
+        throw new AuthRequiredError('Authentication required')
+      }
+
+      const did = agent.assertDid
+
+      const profileResponse = await agent.com.atproto.repo
+        .getRecord({
+          repo: did,
+          collection: 'app.bsky.actor.profile',
+          rkey: 'self',
+        })
+        .catch(() => undefined)
+
+      const profileRecord = profileResponse?.data
+      let profile: AppBskyActorProfile.Record = {} as AppBskyActorProfile.Record
+
+      if (profileRecord && AppBskyActorProfile.isRecord(profileRecord.value)) {
+        const validated = AppBskyActorProfile.validateRecord(
+          profileRecord.value,
+        )
+        if (validated.success) {
+          profile = profileRecord.value
+        } else {
+          ctx.logger.error(
+            { err: validated.error },
+            'Failed to validate user profile',
+          )
+        }
+      }
+
+      // Fetch user status
+      const status = await ctx.db
+        .selectFrom('status')
+        .selectAll()
+        .where('authorDid', '=', did)
+        .orderBy('indexedAt', 'desc')
+        .executeTakeFirst()
+
+      return {
+        encoding: 'application/json',
+        body: {
+          profile: await bskyProfileToProfileView(did, profile, ctx),
+          status: status ? await statusToStatusView(status, ctx) : undefined,
+        },
+      }
+    },
+  })
+}

packages/appview/src/api/lexicons/sendStatus.ts

···
+import { TID } from '@atproto/common'
+import {
+  AuthRequiredError,
+  InvalidRequestError,
+  UpstreamFailureError,
+} from '@atproto/xrpc-server'
+import { XyzStatusphereStatus } from '@statusphere/lexicon'
+
+import { AppContext } from '#/context'
+import { Server } from '#/lexicons'
+import { statusToStatusView } from '#/lib/hydrate'
+import { getSessionAgent } from '#/session'
+
+export default function (server: Server, ctx: AppContext) {
+  server.xyz.statusphere.sendStatus({
+    handler: async ({ input, req, res }) => {
+      const agent = await getSessionAgent(req, res, ctx)
+      if (!agent) {
+        throw new AuthRequiredError('Authentication required')
+      }
+
+      // Construct & validate their status record
+      const rkey = TID.nextStr()
+      const record = {
+        $type: 'xyz.statusphere.status',
+        status: input.body.status,
+        createdAt: new Date().toISOString(),
+      }
+
+      const validation = XyzStatusphereStatus.validateRecord(record)
+      if (!validation.success) {
+        throw new InvalidRequestError('Invalid status')
+      }
+
+      let uri
+      try {
+        // Write the status record to the user's repository
+        const response = await agent.com.atproto.repo.putRecord({
+          repo: agent.assertDid,
+          collection: 'xyz.statusphere.status',
+          rkey,
+          record: validation.value,
+          validate: false,
+        })
+        uri = response.data.uri
+      } catch (err) {
+        throw new UpstreamFailureError('Failed to write record')
+      }
+
+      const optimisticStatus = {
+        uri,
+        authorDid: agent.assertDid,
+        status: record.status,
+        createdAt: record.createdAt,
+        indexedAt: new Date().toISOString(),
+      }
+
+      try {
+        // Optimistically update our SQLite
+        // This isn't strictly necessary because the write event will be
+        // handled in #/firehose/ingestor.ts, but it ensures that future reads
+        // will be up-to-date after this method finishes.
+        await ctx.db.insertInto('status').values(optimisticStatus).execute()
+      } catch (err) {
+        ctx.logger.warn(
+          { err },
+          'failed to update computed view; ignoring as it should be caught by the firehose',
+        )
+      }
+
+      return {
+        encoding: 'application/json',
+        body: {
+          status: await statusToStatusView(optimisticStatus, ctx),
+        },
+      }
+    },
+  })
+}

packages/appview/src/api/oauth.ts

···
+import { OAuthResolverError } from '@atproto/oauth-client-node'
+import { isValidHandle } from '@atproto/syntax'
+import express from 'express'
+
+import { AppContext } from '#/context'
+import { getSession } from '#/session'
+
+export const createRouter = (ctx: AppContext) => {
+  const router = express.Router()
+
+  // OAuth metadata
+  router.get('/client-metadata.json', (_req, res) => {
+    res.json(ctx.oauthClient.clientMetadata)
+  })
+
+  // OAuth callback to complete session creation
+  router.get('/oauth/callback', async (req, res) => {
+    // Get the query parameters from the URL
+    const params = new URLSearchParams(req.originalUrl.split('?')[1])
+
+    try {
+      const { session } = await ctx.oauthClient.callback(params)
+
+      // Use the common session options
+      const clientSession = await getSession(req, res)
+
+      // Set the DID on the session
+      clientSession.did = session.did
+      await clientSession.save()
+
+      // Get the origin and determine appropriate redirect
+      const host = req.get('host') || ''
+      const protocol = req.protocol || 'http'
+      const baseUrl = `${protocol}://${host}`
+
+      ctx.logger.info(
+        `OAuth callback successful, redirecting to ${baseUrl}/oauth-callback`,
+      )
+
+      // Redirect to the frontend oauth-callback page
+      res.redirect('/oauth-callback')
+    } catch (err) {
+      ctx.logger.error({ err }, 'oauth callback failed')
+
+      // Handle error redirect - stay on same domain
+      res.redirect('/oauth-callback?error=auth')
+    }
+  })
+
+  // Login handler
+  router.post('/oauth/initiate', async (req, res) => {
+    // Validate
+    const handle = req.body?.handle
+    if (typeof handle !== 'string' || !isValidHandle(handle)) {
+      res.status(400).json({ error: 'Invalid handle' })
+      return
+    }
+
+    // Initiate the OAuth flow
+    try {
+      const url = await ctx.oauthClient.authorize(handle, {
+        scope: 'atproto transition:generic',
+      })
+      res.json({ redirectUrl: url.toString() })
+    } catch (err) {
+      ctx.logger.error({ err }, 'oauth authorize failed')
+      const errorMsg =
+        err instanceof OAuthResolverError
+          ? err.message
+          : "Couldn't initiate login"
+      res.status(500).json({ error: errorMsg })
+    }
+  })
+
+  // Logout handler
+  router.post('/oauth/logout', async (req, res) => {
+    const session = await getSession(req, res)
+    session.destroy()
+    res.json({ success: true })
+  })
+
+  return router
+}

packages/appview/src/auth/client.ts

···
     clientMetadata: {
       client_name: 'Statusphere React App',
       client_id: publicUrl
-        ? `${url}/api/client-metadata.json`
-        : `http://localhost?redirect_uri=${enc(`${url}/api/oauth/callback`)}&scope=${enc('atproto transition:generic')}`,
+        ? `${url}/client-metadata.json`
+        : `http://localhost?redirect_uri=${enc(`${url}/oauth/callback`)}&scope=${enc('atproto transition:generic')}`,
       client_uri: url,
-      redirect_uris: [`${url}/api/oauth/callback`],
+      redirect_uris: [`${url}/oauth/callback`],
       scope: 'atproto transition:generic',
       grant_types: ['authorization_code', 'refresh_token'],
       response_types: ['code'],

packages/appview/src/context.ts

···
+import { OAuthClient } from '@atproto/oauth-client-node'
+import { Firehose } from '@atproto/sync'
+import pino from 'pino'
+
+import { Database } from './db'
+import { BidirectionalResolver } from './id-resolver'
+
+// Application state passed to the router and elsewhere
+export type AppContext = {
+  db: Database
+  ingester: Firehose
+  logger: pino.Logger
+  oauthClient: OAuthClient
+  resolver: BidirectionalResolver
+}

packages/appview/src/error.ts

···
+import { XRPCError } from '@atproto/xrpc-server'
+import { ErrorRequestHandler } from 'express'
+
+import { AppContext } from '#/context'
+
+export const createHandler: (ctx: AppContext) => ErrorRequestHandler =
+  (ctx) => (err, _req, res, next) => {
+    ctx.logger.error('unexpected internal server error', err)
+    if (res.headersSent) {
+      return next(err)
+    }
+    const serverError = XRPCError.fromError(err)
+    res.status(serverError.type).json(serverError.payload)
+  }

packages/appview/src/index.ts

···
 import fs from 'node:fs'
 import type http from 'node:http'
 import path from 'node:path'
-import type { OAuthClient } from '@atproto/oauth-client-node'
-import { Firehose } from '@atproto/sync'
+import { DAY, SECOND } from '@atproto/common'
+import compression from 'compression'
 import cors from 'cors'
-import express, { type Express } from 'express'
+import express from 'express'
 import { pino } from 'pino'
 
+import API, { health, oauth } from '#/api'
 import { createClient } from '#/auth/client'
+import { AppContext } from '#/context'
 import { createDb, migrateToLatest } from '#/db'
-import type { Database } from '#/db'
-import {
-  BidirectionalResolver,
-  createBidirectionalResolver,
-  createIdResolver,
-} from '#/id-resolver'
+import * as error from '#/error'
+import { createBidirectionalResolver, createIdResolver } from '#/id-resolver'
 import { createIngester } from '#/ingester'
+import { createServer } from '#/lexicons'
 import { env } from '#/lib/env'
-import { createRouter } from '#/routes'
-
-// Application state passed to the router and elsewhere
-export type AppContext = {
-  db: Database
-  ingester: Firehose
-  logger: pino.Logger
-  oauthClient: OAuthClient
-  resolver: BidirectionalResolver
-}
 
 export class Server {
   constructor(
···
     // Subscribe to events on the firehose
     ingester.start()
 
-    // Create our server
-    const app: Express = express()
-    app.set('trust proxy', true)
-
-    // CORS configuration based on environment
-    if (env.NODE_ENV === 'development') {
-      // In development, allow multiple origins including ngrok
-      app.use(
-        cors({
-          origin: function (origin, callback) {
-            // Allow requests with no origin (like mobile apps, curl)
-            if (!origin) return callback(null, true)
-
-            // List of allowed origins
-            const allowedOrigins = [
-              'http://localhost:3000', // Standard React port
-              'http://127.0.0.1:3000', // Alternative React address
-            ]
-
-            // Check if the request origin is in our allowed list or is an ngrok domain
-            if (allowedOrigins.indexOf(origin) !== -1) {
-              callback(null, true)
-            } else {
-              console.warn(`⚠️ CORS blocked origin: ${origin}`)
-              callback(null, false)
-            }
-          },
-          credentials: true,
-          methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
-          allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
-        }),
-      )
-    } else {
-      // In production, CORS is not needed if frontend and API are on same domain
-      // But we'll still enable it for flexibility with minimal configuration
-      app.use(
-        cors({
-          origin: true, // Use req.origin, which means same-origin requests will always be allowed
-          credentials: true,
-        }),
-      )
-    }
-
-    // Routes & middlewares
-    const router = createRouter(ctx)
+    const app = express()
+    app.use(cors({ maxAge: DAY / SECOND }))
+    app.use(compression())
     app.use(express.json())
     app.use(express.urlencoded({ extended: true }))
 
-    app.use('/api', router)
+    // Create our server
+    let server = createServer({
+      validateResponse: env.isDevelopment,
+      payload: {
+        jsonLimit: 100 * 1024, // 100kb
+        textLimit: 100 * 1024, // 100kb
+        // no blobs
+        blobLimit: 0,
+      },
+    })
+
+    server = API(server, ctx)
+
+    app.use(health.createRouter(ctx))
+    app.use(oauth.createRouter(ctx))
+    app.use(server.xrpc.router)
+    app.use(error.createHandler(ctx))
 
     // Serve static files from the frontend build - prod only
     if (env.isProduction) {
···
         // Serve static files
         app.use(express.static(frontendPath))
 
-        // Heathcheck
-        app.get('/health', (req, res) => {
-          res.status(200).json({ status: 'ok' })
-        })
-
         // For any other requests, send the index.html file
         app.get('*', (req, res) => {
           // Only handle non-API paths
-          if (!req.path.startsWith('/api/')) {
+          if (!req.path.startsWith('/xrpc/')) {
             res.sendFile(path.join(frontendPath, 'index.html'))
           } else {
             res.status(404).json({ error: 'API endpoint not found' })
···
           res.sendStatus(404)
         })
       }
+    } else {
+      server.xrpc.router.set('trust proxy', true)
     }
 
     // Use the port from env (should be 3001 for the API server)
-    const server = app.listen(env.PORT)
-    await events.once(server, 'listening')
+    const httpServer = app.listen(env.PORT)
+    await events.once(httpServer, 'listening')
     logger.info(
       `API Server (${NODE_ENV}) running on port http://${HOST}:${env.PORT}`,
     )
 
-    return new Server(app, server, ctx)
+    return new Server(app, httpServer, ctx)
   }
 
   async close() {

packages/appview/src/lexicons/index.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  AuthVerifier,
+  createServer as createXrpcServer,
+  StreamAuthVerifier,
+  Options as XrpcOptions,
+  Server as XrpcServer,
+} from '@atproto/xrpc-server'
+
+import { schemas } from './lexicons.js'
+import * as ComAtprotoRepoApplyWrites from './types/com/atproto/repo/applyWrites.js'
+import * as ComAtprotoRepoCreateRecord from './types/com/atproto/repo/createRecord.js'
+import * as ComAtprotoRepoDeleteRecord from './types/com/atproto/repo/deleteRecord.js'
+import * as ComAtprotoRepoDescribeRepo from './types/com/atproto/repo/describeRepo.js'
+import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord.js'
+import * as ComAtprotoRepoImportRepo from './types/com/atproto/repo/importRepo.js'
+import * as ComAtprotoRepoListMissingBlobs from './types/com/atproto/repo/listMissingBlobs.js'
+import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords.js'
+import * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord.js'
+import * as ComAtprotoRepoUploadBlob from './types/com/atproto/repo/uploadBlob.js'
+import * as XyzStatusphereGetStatuses from './types/xyz/statusphere/getStatuses.js'
+import * as XyzStatusphereGetUser from './types/xyz/statusphere/getUser.js'
+import * as XyzStatusphereSendStatus from './types/xyz/statusphere/sendStatus.js'
+
+export function createServer(options?: XrpcOptions): Server {
+  return new Server(options)
+}
+
+export class Server {
+  xrpc: XrpcServer
+  xyz: XyzNS
+  com: ComNS
+  app: AppNS
+
+  constructor(options?: XrpcOptions) {
+    this.xrpc = createXrpcServer(schemas, options)
+    this.xyz = new XyzNS(this)
+    this.com = new ComNS(this)
+    this.app = new AppNS(this)
+  }
+}
+
+export class XyzNS {
+  _server: Server
+  statusphere: XyzStatusphereNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.statusphere = new XyzStatusphereNS(server)
+  }
+}
+
+export class XyzStatusphereNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  getStatuses<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      XyzStatusphereGetStatuses.Handler<ExtractAuth<AV>>,
+      XyzStatusphereGetStatuses.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'xyz.statusphere.getStatuses' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getUser<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      XyzStatusphereGetUser.Handler<ExtractAuth<AV>>,
+      XyzStatusphereGetUser.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'xyz.statusphere.getUser' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  sendStatus<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      XyzStatusphereSendStatus.Handler<ExtractAuth<AV>>,
+      XyzStatusphereSendStatus.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'xyz.statusphere.sendStatus' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class ComNS {
+  _server: Server
+  atproto: ComAtprotoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.atproto = new ComAtprotoNS(server)
+  }
+}
+
+export class ComAtprotoNS {
+  _server: Server
+  repo: ComAtprotoRepoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.repo = new ComAtprotoRepoNS(server)
+  }
+}
+
+export class ComAtprotoRepoNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+
+  applyWrites<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoApplyWrites.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoApplyWrites.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.applyWrites' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  createRecord<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoCreateRecord.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoCreateRecord.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.createRecord' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  deleteRecord<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoDeleteRecord.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoDeleteRecord.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.deleteRecord' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  describeRepo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoDescribeRepo.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoDescribeRepo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.describeRepo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  getRecord<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoGetRecord.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoGetRecord.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.getRecord' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  importRepo<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoImportRepo.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoImportRepo.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.importRepo' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  listMissingBlobs<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoListMissingBlobs.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoListMissingBlobs.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.listMissingBlobs' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  listRecords<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoListRecords.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoListRecords.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.listRecords' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  putRecord<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoPutRecord.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoPutRecord.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.putRecord' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+
+  uploadBlob<AV extends AuthVerifier>(
+    cfg: ConfigOf<
+      AV,
+      ComAtprotoRepoUploadBlob.Handler<ExtractAuth<AV>>,
+      ComAtprotoRepoUploadBlob.HandlerReqCtx<ExtractAuth<AV>>
+    >,
+  ) {
+    const nsid = 'com.atproto.repo.uploadBlob' // @ts-ignore
+    return this._server.xrpc.method(nsid, cfg)
+  }
+}
+
+export class AppNS {
+  _server: Server
+  bsky: AppBskyNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.bsky = new AppBskyNS(server)
+  }
+}
+
+export class AppBskyNS {
+  _server: Server
+  actor: AppBskyActorNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.actor = new AppBskyActorNS(server)
+  }
+}
+
+export class AppBskyActorNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+type SharedRateLimitOpts<T> = {
+  name: string
+  calcKey?: (ctx: T) => string | null
+  calcPoints?: (ctx: T) => number
+}
+type RouteRateLimitOpts<T> = {
+  durationMs: number
+  points: number
+  calcKey?: (ctx: T) => string | null
+  calcPoints?: (ctx: T) => number
+}
+type HandlerOpts = { blobLimit?: number }
+type HandlerRateLimitOpts<T> = SharedRateLimitOpts<T> | RouteRateLimitOpts<T>
+type ConfigOf<Auth, Handler, ReqCtx> =
+  | Handler
+  | {
+      auth?: Auth
+      opts?: HandlerOpts
+      rateLimit?: HandlerRateLimitOpts<ReqCtx> | HandlerRateLimitOpts<ReqCtx>[]
+      handler: Handler
+    }
+type ExtractAuth<AV extends AuthVerifier | StreamAuthVerifier> = Extract<
+  Awaited<ReturnType<AV>>,
+  { credentials: unknown }
+>

packages/appview/src/lexicons/lexicons.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  LexiconDoc,
+  Lexicons,
+  ValidationError,
+  ValidationResult,
+} from '@atproto/lexicon'
+
+import { $Typed, is$typed, maybe$typed } from './util.js'
+
+export const schemaDict = {
+  XyzStatusphereDefs: {
+    lexicon: 1,
+    id: 'xyz.statusphere.defs',
+    defs: {
+      statusView: {
+        type: 'object',
+        required: ['uri', 'status', 'profile', 'createdAt'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          status: {
+            type: 'string',
+            minLength: 1,
+            maxGraphemes: 1,
+            maxLength: 32,
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          profile: {
+            type: 'ref',
+            ref: 'lex:xyz.statusphere.defs#profileView',
+          },
+        },
+      },
+      profileView: {
+        type: 'object',
+        required: ['did', 'handle'],
+        properties: {
+          did: {
+            type: 'string',
+            format: 'did',
+          },
+          handle: {
+            type: 'string',
+            format: 'handle',
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereGetStatuses: {
+    lexicon: 1,
+    id: 'xyz.statusphere.getStatuses',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a list of the most recent statuses on the network.',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['statuses'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              statuses: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:xyz.statusphere.defs#statusView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereGetUser: {
+    lexicon: 1,
+    id: 'xyz.statusphere.getUser',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get the current user's profile and status.",
+        parameters: {
+          type: 'params',
+          properties: {},
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['profile'],
+            properties: {
+              profile: {
+                type: 'ref',
+                ref: 'lex:app.bsky.actor.defs#profileView',
+              },
+              status: {
+                type: 'ref',
+                ref: 'lex:xyz.statusphere.defs#statusView',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereSendStatus: {
+    lexicon: 1,
+    id: 'xyz.statusphere.sendStatus',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Send a status into the ATmosphere.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['status'],
+            properties: {
+              status: {
+                type: 'string',
+                minLength: 1,
+                maxGraphemes: 1,
+                maxLength: 32,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['status'],
+            properties: {
+              status: {
+                type: 'ref',
+                ref: 'lex:xyz.statusphere.defs#statusView',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereStatus: {
+    lexicon: 1,
+    id: 'xyz.statusphere.status',
+    defs: {
+      main: {
+        type: 'record',
+        key: 'tid',
+        record: {
+          type: 'object',
+          required: ['status', 'createdAt'],
+          properties: {
+            status: {
+              type: 'string',
+              minLength: 1,
+              maxGraphemes: 1,
+              maxLength: 32,
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoLabelDefs: {
+    lexicon: 1,
+    id: 'com.atproto.label.defs',
+    defs: {
+      label: {
+        type: 'object',
+        description:
+          'Metadata tag on an atproto resource (eg, repo or record).',
+        required: ['src', 'uri', 'val', 'cts'],
+        properties: {
+          ver: {
+            type: 'integer',
+            description: 'The AT Protocol version of the label object.',
+          },
+          src: {
+            type: 'string',
+            format: 'did',
+            description: 'DID of the actor who created this label.',
+          },
+          uri: {
+            type: 'string',
+            format: 'uri',
+            description:
+              'AT URI of the record, repository (account), or other resource that this label applies to.',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+            description:
+              "Optionally, CID specifying the specific version of 'uri' resource this label applies to.",
+          },
+          val: {
+            type: 'string',
+            maxLength: 128,
+            description:
+              'The short string name of the value or type of this label.',
+          },
+          neg: {
+            type: 'boolean',
+            description:
+              'If true, this is a negation label, overwriting a previous label.',
+          },
+          cts: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Timestamp when this label was created.',
+          },
+          exp: {
+            type: 'string',
+            format: 'datetime',
+            description:
+              'Timestamp at which this label expires (no longer applies).',
+          },
+          sig: {
+            type: 'bytes',
+            description: 'Signature of dag-cbor encoded label.',
+          },
+        },
+      },
+      selfLabels: {
+        type: 'object',
+        description:
+          'Metadata tags on an atproto record, published by the author within the record.',
+        required: ['values'],
+        properties: {
+          values: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#selfLabel',
+            },
+            maxLength: 10,
+          },
+        },
+      },
+      selfLabel: {
+        type: 'object',
+        description:
+          'Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.',
+        required: ['val'],
+        properties: {
+          val: {
+            type: 'string',
+            maxLength: 128,
+            description:
+              'The short string name of the value or type of this label.',
+          },
+        },
+      },
+      labelValueDefinition: {
+        type: 'object',
+        description:
+          'Declares a label value and its expected interpretations and behaviors.',
+        required: ['identifier', 'severity', 'blurs', 'locales'],
+        properties: {
+          identifier: {
+            type: 'string',
+            description:
+              "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",
+            maxLength: 100,
+            maxGraphemes: 100,
+          },
+          severity: {
+            type: 'string',
+            description:
+              "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",
+            knownValues: ['inform', 'alert', 'none'],
+          },
+          blurs: {
+            type: 'string',
+            description:
+              "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",
+            knownValues: ['content', 'media', 'none'],
+          },
+          defaultSetting: {
+            type: 'string',
+            description: 'The default setting for this label.',
+            knownValues: ['ignore', 'warn', 'hide'],
+            default: 'warn',
+          },
+          adultOnly: {
+            type: 'boolean',
+            description:
+              'Does the user need to have adult content enabled in order to configure this label?',
+          },
+          locales: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#labelValueDefinitionStrings',
+            },
+          },
+        },
+      },
+      labelValueDefinitionStrings: {
+        type: 'object',
+        description:
+          'Strings which describe the label in the UI, localized into a specific language.',
+        required: ['lang', 'name', 'description'],
+        properties: {
+          lang: {
+            type: 'string',
+            description:
+              'The code of the language these strings are written in.',
+            format: 'language',
+          },
+          name: {
+            type: 'string',
+            description: 'A short human-readable name for the label.',
+            maxGraphemes: 64,
+            maxLength: 640,
+          },
+          description: {
+            type: 'string',
+            description:
+              'A longer description of what the label means and why it might be applied.',
+            maxGraphemes: 10000,
+            maxLength: 100000,
+          },
+        },
+      },
+      labelValue: {
+        type: 'string',
+        knownValues: [
+          '!hide',
+          '!no-promote',
+          '!warn',
+          '!no-unauthenticated',
+          'dmca-violation',
+          'doxxing',
+          'porn',
+          'sexual',
+          'nudity',
+          'nsfl',
+          'gore',
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoApplyWrites: {
+    lexicon: 1,
+    id: 'com.atproto.repo.applyWrites',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Apply a batch transaction of repository creates, updates, and deletes. Requires auth, implemented by PDS.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'writes'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-identifier',
+                description:
+                  'The handle or DID of the repo (aka, current account).',
+              },
+              validate: {
+                type: 'boolean',
+                description:
+                  "Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons.",
+              },
+              writes: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:com.atproto.repo.applyWrites#create',
+                    'lex:com.atproto.repo.applyWrites#update',
+                    'lex:com.atproto.repo.applyWrites#delete',
+                  ],
+                  closed: true,
+                },
+              },
+              swapCommit: {
+                type: 'string',
+                description:
+                  'If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations.',
+                format: 'cid',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: [],
+            properties: {
+              commit: {
+                type: 'ref',
+                ref: 'lex:com.atproto.repo.defs#commitMeta',
+              },
+              results: {
+                type: 'array',
+                items: {
+                  type: 'union',
+                  refs: [
+                    'lex:com.atproto.repo.applyWrites#createResult',
+                    'lex:com.atproto.repo.applyWrites#updateResult',
+                    'lex:com.atproto.repo.applyWrites#deleteResult',
+                  ],
+                  closed: true,
+                },
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InvalidSwap',
+            description:
+              "Indicates that the 'swapCommit' parameter did not match current commit.",
+          },
+        ],
+      },
+      create: {
+        type: 'object',
+        description: 'Operation which creates a new record.',
+        required: ['collection', 'value'],
+        properties: {
+          collection: {
+            type: 'string',
+            format: 'nsid',
+          },
+          rkey: {
+            type: 'string',
+            maxLength: 512,
+            format: 'record-key',
+            description:
+              'NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility.',
+          },
+          value: {
+            type: 'unknown',
+          },
+        },
+      },
+      update: {
+        type: 'object',
+        description: 'Operation which updates an existing record.',
+        required: ['collection', 'rkey', 'value'],
+        properties: {
+          collection: {
+            type: 'string',
+            format: 'nsid',
+          },
+          rkey: {
+            type: 'string',
+            format: 'record-key',
+          },
+          value: {
+            type: 'unknown',
+          },
+        },
+      },
+      delete: {
+        type: 'object',
+        description: 'Operation which deletes an existing record.',
+        required: ['collection', 'rkey'],
+        properties: {
+          collection: {
+            type: 'string',
+            format: 'nsid',
+          },
+          rkey: {
+            type: 'string',
+            format: 'record-key',
+          },
+        },
+      },
+      createResult: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          validationStatus: {
+            type: 'string',
+            knownValues: ['valid', 'unknown'],
+          },
+        },
+      },
+      updateResult: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          validationStatus: {
+            type: 'string',
+            knownValues: ['valid', 'unknown'],
+          },
+        },
+      },
+      deleteResult: {
+        type: 'object',
+        required: [],
+        properties: {},
+      },
+    },
+  },
+  ComAtprotoRepoCreateRecord: {
+    lexicon: 1,
+    id: 'com.atproto.repo.createRecord',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Create a single new repository record. Requires auth, implemented by PDS.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'collection', 'record'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-identifier',
+                description:
+                  'The handle or DID of the repo (aka, current account).',
+              },
+              collection: {
+                type: 'string',
+                format: 'nsid',
+                description: 'The NSID of the record collection.',
+              },
+              rkey: {
+                type: 'string',
+                format: 'record-key',
+                description: 'The Record Key.',
+                maxLength: 512,
+              },
+              validate: {
+                type: 'boolean',
+                description:
+                  "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",
+              },
+              record: {
+                type: 'unknown',
+                description: 'The record itself. Must contain a $type field.',
+              },
+              swapCommit: {
+                type: 'string',
+                format: 'cid',
+                description:
+                  'Compare and swap with the previous commit by CID.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri', 'cid'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              cid: {
+                type: 'string',
+                format: 'cid',
+              },
+              commit: {
+                type: 'ref',
+                ref: 'lex:com.atproto.repo.defs#commitMeta',
+              },
+              validationStatus: {
+                type: 'string',
+                knownValues: ['valid', 'unknown'],
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InvalidSwap',
+            description:
+              "Indicates that 'swapCommit' didn't match current repo commit.",
+          },
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoDefs: {
+    lexicon: 1,
+    id: 'com.atproto.repo.defs',
+    defs: {
+      commitMeta: {
+        type: 'object',
+        required: ['cid', 'rev'],
+        properties: {
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          rev: {
+            type: 'string',
+            format: 'tid',
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoDeleteRecord: {
+    lexicon: 1,
+    id: 'com.atproto.repo.deleteRecord',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'collection', 'rkey'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-identifier',
+                description:
+                  'The handle or DID of the repo (aka, current account).',
+              },
+              collection: {
+                type: 'string',
+                format: 'nsid',
+                description: 'The NSID of the record collection.',
+              },
+              rkey: {
+                type: 'string',
+                format: 'record-key',
+                description: 'The Record Key.',
+              },
+              swapRecord: {
+                type: 'string',
+                format: 'cid',
+                description:
+                  'Compare and swap with the previous record by CID.',
+              },
+              swapCommit: {
+                type: 'string',
+                format: 'cid',
+                description:
+                  'Compare and swap with the previous commit by CID.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            properties: {
+              commit: {
+                type: 'ref',
+                ref: 'lex:com.atproto.repo.defs#commitMeta',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InvalidSwap',
+          },
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoDescribeRepo: {
+    lexicon: 1,
+    id: 'com.atproto.repo.describeRepo',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get information about an account and repository, including the list of collections. Does not require auth.',
+        parameters: {
+          type: 'params',
+          required: ['repo'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The handle or DID of the repo.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: [
+              'handle',
+              'did',
+              'didDoc',
+              'collections',
+              'handleIsCorrect',
+            ],
+            properties: {
+              handle: {
+                type: 'string',
+                format: 'handle',
+              },
+              did: {
+                type: 'string',
+                format: 'did',
+              },
+              didDoc: {
+                type: 'unknown',
+                description: 'The complete DID document for this account.',
+              },
+              collections: {
+                type: 'array',
+                description:
+                  'List of all the collections (NSIDs) for which this repo contains at least one record.',
+                items: {
+                  type: 'string',
+                  format: 'nsid',
+                },
+              },
+              handleIsCorrect: {
+                type: 'boolean',
+                description:
+                  'Indicates if handle is currently valid (resolves bi-directionally)',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoGetRecord: {
+    lexicon: 1,
+    id: 'com.atproto.repo.getRecord',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Get a single record from a repository. Does not require auth.',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'collection', 'rkey'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The handle or DID of the repo.',
+            },
+            collection: {
+              type: 'string',
+              format: 'nsid',
+              description: 'The NSID of the record collection.',
+            },
+            rkey: {
+              type: 'string',
+              description: 'The Record Key.',
+              format: 'record-key',
+            },
+            cid: {
+              type: 'string',
+              format: 'cid',
+              description:
+                'The CID of the version of the record. If not specified, then return the most recent version.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri', 'value'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              cid: {
+                type: 'string',
+                format: 'cid',
+              },
+              value: {
+                type: 'unknown',
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'RecordNotFound',
+          },
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoImportRepo: {
+    lexicon: 1,
+    id: 'com.atproto.repo.importRepo',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Import a repo in the form of a CAR file. Requires Content-Length HTTP header to be set.',
+        input: {
+          encoding: 'application/vnd.ipld.car',
+        },
+      },
+    },
+  },
+  ComAtprotoRepoListMissingBlobs: {
+    lexicon: 1,
+    id: 'com.atproto.repo.listMissingBlobs',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'Returns a list of missing blobs for the requesting account. Intended to be used in the account migration flow.',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 1000,
+              default: 500,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['blobs'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              blobs: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:com.atproto.repo.listMissingBlobs#recordBlob',
+                },
+              },
+            },
+          },
+        },
+      },
+      recordBlob: {
+        type: 'object',
+        required: ['cid', 'recordUri'],
+        properties: {
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          recordUri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoListRecords: {
+    lexicon: 1,
+    id: 'com.atproto.repo.listRecords',
+    defs: {
+      main: {
+        type: 'query',
+        description:
+          'List a range of records in a repository, matching a specific collection. Does not require auth.',
+        parameters: {
+          type: 'params',
+          required: ['repo', 'collection'],
+          properties: {
+            repo: {
+              type: 'string',
+              format: 'at-identifier',
+              description: 'The handle or DID of the repo.',
+            },
+            collection: {
+              type: 'string',
+              format: 'nsid',
+              description: 'The NSID of the record type.',
+            },
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+              description: 'The number of records to return.',
+            },
+            cursor: {
+              type: 'string',
+            },
+            rkeyStart: {
+              type: 'string',
+              description:
+                'DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)',
+            },
+            rkeyEnd: {
+              type: 'string',
+              description:
+                'DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)',
+            },
+            reverse: {
+              type: 'boolean',
+              description: 'Flag to reverse the order of the returned records.',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['records'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              records: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:com.atproto.repo.listRecords#record',
+                },
+              },
+            },
+          },
+        },
+      },
+      record: {
+        type: 'object',
+        required: ['uri', 'cid', 'value'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+          value: {
+            type: 'unknown',
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoPutRecord: {
+    lexicon: 1,
+    id: 'com.atproto.repo.putRecord',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['repo', 'collection', 'rkey', 'record'],
+            nullable: ['swapRecord'],
+            properties: {
+              repo: {
+                type: 'string',
+                format: 'at-identifier',
+                description:
+                  'The handle or DID of the repo (aka, current account).',
+              },
+              collection: {
+                type: 'string',
+                format: 'nsid',
+                description: 'The NSID of the record collection.',
+              },
+              rkey: {
+                type: 'string',
+                format: 'record-key',
+                description: 'The Record Key.',
+                maxLength: 512,
+              },
+              validate: {
+                type: 'boolean',
+                description:
+                  "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",
+              },
+              record: {
+                type: 'unknown',
+                description: 'The record to write.',
+              },
+              swapRecord: {
+                type: 'string',
+                format: 'cid',
+                description:
+                  'Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation',
+              },
+              swapCommit: {
+                type: 'string',
+                format: 'cid',
+                description:
+                  'Compare and swap with the previous commit by CID.',
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['uri', 'cid'],
+            properties: {
+              uri: {
+                type: 'string',
+                format: 'at-uri',
+              },
+              cid: {
+                type: 'string',
+                format: 'cid',
+              },
+              commit: {
+                type: 'ref',
+                ref: 'lex:com.atproto.repo.defs#commitMeta',
+              },
+              validationStatus: {
+                type: 'string',
+                knownValues: ['valid', 'unknown'],
+              },
+            },
+          },
+        },
+        errors: [
+          {
+            name: 'InvalidSwap',
+          },
+        ],
+      },
+    },
+  },
+  ComAtprotoRepoStrongRef: {
+    lexicon: 1,
+    id: 'com.atproto.repo.strongRef',
+    description: 'A URI with a content-hash fingerprint.',
+    defs: {
+      main: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoUploadBlob: {
+    lexicon: 1,
+    id: 'com.atproto.repo.uploadBlob',
+    defs: {
+      main: {
+        type: 'procedure',
+        description:
+          'Upload a new blob, to be referenced from a repository record. The blob will be deleted if it is not referenced within a time window (eg, minutes). Blob restrictions (mimetype, size, etc) are enforced when the reference is created. Requires auth, implemented by PDS.',
+        input: {
+          encoding: '*/*',
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['blob'],
+            properties: {
+              blob: {
+                type: 'blob',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  AppBskyActorDefs: {
+    lexicon: 1,
+    id: 'app.bsky.actor.defs',
+    defs: {
+      profileView: {
+        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',
+          },
+          indexedAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          createdAt: {
+            type: 'string',
+            format: 'datetime',
+          },
+          labels: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#label',
+            },
+          },
+        },
+      },
+    },
+  },
+  AppBskyActorProfile: {
+    lexicon: 1,
+    id: 'app.bsky.actor.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A declaration of a Bluesky account profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          properties: {
+            displayName: {
+              type: 'string',
+              maxGraphemes: 64,
+              maxLength: 640,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            avatar: {
+              type: 'blob',
+              description:
+                "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            banner: {
+              type: 'blob',
+              description:
+                'Larger horizontal image to display behind profile view.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            labels: {
+              type: 'union',
+              description:
+                'Self-label values, specific to the Bluesky application, on the overall account.',
+              refs: ['lex:com.atproto.label.defs#selfLabels'],
+            },
+            joinedViaStarterPack: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            pinnedPost: {
+              type: 'ref',
+              ref: 'lex:com.atproto.repo.strongRef',
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+} as const satisfies Record<string, LexiconDoc>
+
+export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
+export const lexicons: Lexicons = new Lexicons(schemas)
+
+export function validate<T extends { $type: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType: true,
+): ValidationResult<T>
+export function validate<T extends { $type?: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: false,
+): ValidationResult<T>
+export function validate(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: boolean,
+): ValidationResult {
+  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
+    ? lexicons.validate(`${id}#${hash}`, v)
+    : {
+        success: false,
+        error: new ValidationError(
+          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
+        ),
+      }
+}
+
+export const ids = {
+  XyzStatusphereDefs: 'xyz.statusphere.defs',
+  XyzStatusphereGetStatuses: 'xyz.statusphere.getStatuses',
+  XyzStatusphereGetUser: 'xyz.statusphere.getUser',
+  XyzStatusphereSendStatus: 'xyz.statusphere.sendStatus',
+  XyzStatusphereStatus: 'xyz.statusphere.status',
+  ComAtprotoLabelDefs: 'com.atproto.label.defs',
+  ComAtprotoRepoApplyWrites: 'com.atproto.repo.applyWrites',
+  ComAtprotoRepoCreateRecord: 'com.atproto.repo.createRecord',
+  ComAtprotoRepoDefs: 'com.atproto.repo.defs',
+  ComAtprotoRepoDeleteRecord: 'com.atproto.repo.deleteRecord',
+  ComAtprotoRepoDescribeRepo: 'com.atproto.repo.describeRepo',
+  ComAtprotoRepoGetRecord: 'com.atproto.repo.getRecord',
+  ComAtprotoRepoImportRepo: 'com.atproto.repo.importRepo',
+  ComAtprotoRepoListMissingBlobs: 'com.atproto.repo.listMissingBlobs',
+  ComAtprotoRepoListRecords: 'com.atproto.repo.listRecords',
+  ComAtprotoRepoPutRecord: 'com.atproto.repo.putRecord',
+  ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
+  ComAtprotoRepoUploadBlob: 'com.atproto.repo.uploadBlob',
+  AppBskyActorDefs: 'app.bsky.actor.defs',
+  AppBskyActorProfile: 'app.bsky.actor.profile',
+} as const

packages/appview/src/lexicons/types/app/bsky/actor/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.actor.defs'
+
+export interface ProfileView {
+  $type?: 'app.bsky.actor.defs#profileView'
+  did: string
+  handle: string
+  displayName?: string
+  description?: string
+  avatar?: string
+  indexedAt?: string
+  createdAt?: string
+  labels?: ComAtprotoLabelDefs.Label[]
+}
+
+const hashProfileView = 'profileView'
+
+export function isProfileView<V>(v: V) {
+  return is$typed(v, id, hashProfileView)
+}
+
+export function validateProfileView<V>(v: V) {
+  return validate<ProfileView & V>(v, id, hashProfileView)
+}

packages/appview/src/lexicons/types/app/bsky/actor/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoLabelDefs from '../../../com/atproto/label/defs.js'
+import type * as ComAtprotoRepoStrongRef from '../../../com/atproto/repo/strongRef.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'app.bsky.actor.profile'
+
+export interface Record {
+  $type: 'app.bsky.actor.profile'
+  displayName?: string
+  /** Free-form profile description text. */
+  description?: string
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef
+  labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }
+  joinedViaStarterPack?: ComAtprotoRepoStrongRef.Main
+  pinnedPost?: ComAtprotoRepoStrongRef.Main
+  createdAt?: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

packages/appview/src/lexicons/types/com/atproto/label/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.label.defs'
+
+/** Metadata tag on an atproto resource (eg, repo or record). */
+export interface Label {
+  $type?: 'com.atproto.label.defs#label'
+  /** The AT Protocol version of the label object. */
+  ver?: number
+  /** DID of the actor who created this label. */
+  src: string
+  /** AT URI of the record, repository (account), or other resource that this label applies to. */
+  uri: string
+  /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
+  cid?: string
+  /** The short string name of the value or type of this label. */
+  val: string
+  /** If true, this is a negation label, overwriting a previous label. */
+  neg?: boolean
+  /** Timestamp when this label was created. */
+  cts: string
+  /** Timestamp at which this label expires (no longer applies). */
+  exp?: string
+  /** Signature of dag-cbor encoded label. */
+  sig?: Uint8Array
+}
+
+const hashLabel = 'label'
+
+export function isLabel<V>(v: V) {
+  return is$typed(v, id, hashLabel)
+}
+
+export function validateLabel<V>(v: V) {
+  return validate<Label & V>(v, id, hashLabel)
+}
+
+/** Metadata tags on an atproto record, published by the author within the record. */
+export interface SelfLabels {
+  $type?: 'com.atproto.label.defs#selfLabels'
+  values: SelfLabel[]
+}
+
+const hashSelfLabels = 'selfLabels'
+
+export function isSelfLabels<V>(v: V) {
+  return is$typed(v, id, hashSelfLabels)
+}
+
+export function validateSelfLabels<V>(v: V) {
+  return validate<SelfLabels & V>(v, id, hashSelfLabels)
+}
+
+/** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
+export interface SelfLabel {
+  $type?: 'com.atproto.label.defs#selfLabel'
+  /** The short string name of the value or type of this label. */
+  val: string
+}
+
+const hashSelfLabel = 'selfLabel'
+
+export function isSelfLabel<V>(v: V) {
+  return is$typed(v, id, hashSelfLabel)
+}
+
+export function validateSelfLabel<V>(v: V) {
+  return validate<SelfLabel & V>(v, id, hashSelfLabel)
+}
+
+/** Declares a label value and its expected interpretations and behaviors. */
+export interface LabelValueDefinition {
+  $type?: 'com.atproto.label.defs#labelValueDefinition'
+  /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
+  identifier: string
+  /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
+  severity: 'inform' | 'alert' | 'none' | (string & {})
+  /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
+  blurs: 'content' | 'media' | 'none' | (string & {})
+  /** The default setting for this label. */
+  defaultSetting: 'ignore' | 'warn' | 'hide' | (string & {})
+  /** Does the user need to have adult content enabled in order to configure this label? */
+  adultOnly?: boolean
+  locales: LabelValueDefinitionStrings[]
+}
+
+const hashLabelValueDefinition = 'labelValueDefinition'
+
+export function isLabelValueDefinition<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinition)
+}
+
+export function validateLabelValueDefinition<V>(v: V) {
+  return validate<LabelValueDefinition & V>(v, id, hashLabelValueDefinition)
+}
+
+/** Strings which describe the label in the UI, localized into a specific language. */
+export interface LabelValueDefinitionStrings {
+  $type?: 'com.atproto.label.defs#labelValueDefinitionStrings'
+  /** The code of the language these strings are written in. */
+  lang: string
+  /** A short human-readable name for the label. */
+  name: string
+  /** A longer description of what the label means and why it might be applied. */
+  description: string
+}
+
+const hashLabelValueDefinitionStrings = 'labelValueDefinitionStrings'
+
+export function isLabelValueDefinitionStrings<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinitionStrings)
+}
+
+export function validateLabelValueDefinitionStrings<V>(v: V) {
+  return validate<LabelValueDefinitionStrings & V>(
+    v,
+    id,
+    hashLabelValueDefinitionStrings,
+  )
+}
+
+export type LabelValue =
+  | '!hide'
+  | '!no-promote'
+  | '!warn'
+  | '!no-unauthenticated'
+  | 'dmca-violation'
+  | 'doxxing'
+  | 'porn'
+  | 'sexual'
+  | 'nudity'
+  | 'nsfl'
+  | 'gore'
+  | (string & {})

packages/appview/src/lexicons/types/com/atproto/repo/applyWrites.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.applyWrites'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The handle or DID of the repo (aka, current account). */
+  repo: string
+  /** Can be set to 'false' to skip Lexicon schema validation of record data across all operations, 'true' to require it, or leave unset to validate only for known Lexicons. */
+  validate?: boolean
+  writes: ($Typed<Create> | $Typed<Update> | $Typed<Delete>)[]
+  /** If provided, the entire operation will fail if the current repo commit CID does not match this value. Used to prevent conflicting repo mutations. */
+  swapCommit?: string
+}
+
+export interface OutputSchema {
+  commit?: ComAtprotoRepoDefs.CommitMeta
+  results?: (
+    | $Typed<CreateResult>
+    | $Typed<UpdateResult>
+    | $Typed<DeleteResult>
+  )[]
+}
+
+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
+  error?: 'InvalidSwap'
+}
+
+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
+
+/** Operation which creates a new record. */
+export interface Create {
+  $type?: 'com.atproto.repo.applyWrites#create'
+  collection: string
+  /** NOTE: maxLength is redundant with record-key format. Keeping it temporarily to ensure backwards compatibility. */
+  rkey?: string
+  value: { [_ in string]: unknown }
+}
+
+const hashCreate = 'create'
+
+export function isCreate<V>(v: V) {
+  return is$typed(v, id, hashCreate)
+}
+
+export function validateCreate<V>(v: V) {
+  return validate<Create & V>(v, id, hashCreate)
+}
+
+/** Operation which updates an existing record. */
+export interface Update {
+  $type?: 'com.atproto.repo.applyWrites#update'
+  collection: string
+  rkey: string
+  value: { [_ in string]: unknown }
+}
+
+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)
+}
+
+/** Operation which deletes an existing record. */
+export interface Delete {
+  $type?: 'com.atproto.repo.applyWrites#delete'
+  collection: string
+  rkey: string
+}
+
+const hashDelete = 'delete'
+
+export function isDelete<V>(v: V) {
+  return is$typed(v, id, hashDelete)
+}
+
+export function validateDelete<V>(v: V) {
+  return validate<Delete & V>(v, id, hashDelete)
+}
+
+export interface CreateResult {
+  $type?: 'com.atproto.repo.applyWrites#createResult'
+  uri: string
+  cid: string
+  validationStatus?: 'valid' | 'unknown' | (string & {})
+}
+
+const hashCreateResult = 'createResult'
+
+export function isCreateResult<V>(v: V) {
+  return is$typed(v, id, hashCreateResult)
+}
+
+export function validateCreateResult<V>(v: V) {
+  return validate<CreateResult & V>(v, id, hashCreateResult)
+}
+
+export interface UpdateResult {
+  $type?: 'com.atproto.repo.applyWrites#updateResult'
+  uri: string
+  cid: string
+  validationStatus?: 'valid' | 'unknown' | (string & {})
+}
+
+const hashUpdateResult = 'updateResult'
+
+export function isUpdateResult<V>(v: V) {
+  return is$typed(v, id, hashUpdateResult)
+}
+
+export function validateUpdateResult<V>(v: V) {
+  return validate<UpdateResult & V>(v, id, hashUpdateResult)
+}
+
+export interface DeleteResult {
+  $type?: 'com.atproto.repo.applyWrites#deleteResult'
+}
+
+const hashDeleteResult = 'deleteResult'
+
+export function isDeleteResult<V>(v: V) {
+  return is$typed(v, id, hashDeleteResult)
+}
+
+export function validateDeleteResult<V>(v: V) {
+  return validate<DeleteResult & V>(v, id, hashDeleteResult)
+}

packages/appview/src/lexicons/types/com/atproto/repo/createRecord.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.createRecord'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The handle or DID of the repo (aka, current account). */
+  repo: string
+  /** The NSID of the record collection. */
+  collection: string
+  /** The Record Key. */
+  rkey?: string
+  /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
+  validate?: boolean
+  /** The record itself. Must contain a $type field. */
+  record: { [_ in string]: unknown }
+  /** Compare and swap with the previous commit by CID. */
+  swapCommit?: string
+}
+
+export interface OutputSchema {
+  uri: string
+  cid: string
+  commit?: ComAtprotoRepoDefs.CommitMeta
+  validationStatus?: 'valid' | 'unknown' | (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
+  error?: 'InvalidSwap'
+}
+
+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

packages/appview/src/lexicons/types/com/atproto/repo/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.defs'
+
+export interface CommitMeta {
+  $type?: 'com.atproto.repo.defs#commitMeta'
+  cid: string
+  rev: string
+}
+
+const hashCommitMeta = 'commitMeta'
+
+export function isCommitMeta<V>(v: V) {
+  return is$typed(v, id, hashCommitMeta)
+}
+
+export function validateCommitMeta<V>(v: V) {
+  return validate<CommitMeta & V>(v, id, hashCommitMeta)
+}

packages/appview/src/lexicons/types/com/atproto/repo/deleteRecord.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.deleteRecord'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The handle or DID of the repo (aka, current account). */
+  repo: string
+  /** The NSID of the record collection. */
+  collection: string
+  /** The Record Key. */
+  rkey: string
+  /** Compare and swap with the previous record by CID. */
+  swapRecord?: string
+  /** Compare and swap with the previous commit by CID. */
+  swapCommit?: string
+}
+
+export interface OutputSchema {
+  commit?: ComAtprotoRepoDefs.CommitMeta
+}
+
+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
+  error?: 'InvalidSwap'
+}
+
+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

packages/appview/src/lexicons/types/com/atproto/repo/describeRepo.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.describeRepo'
+
+export interface QueryParams {
+  /** The handle or DID of the repo. */
+  repo: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  handle: string
+  did: string
+  /** The complete DID document for this account. */
+  didDoc: { [_ in string]: unknown }
+  /** List of all the collections (NSIDs) for which this repo contains at least one record. */
+  collections: string[]
+  /** Indicates if handle is currently valid (resolves bi-directionally) */
+  handleIsCorrect: boolean
+}
+
+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

packages/appview/src/lexicons/types/com/atproto/repo/getRecord.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.getRecord'
+
+export interface QueryParams {
+  /** The handle or DID of the repo. */
+  repo: string
+  /** The NSID of the record collection. */
+  collection: string
+  /** The Record Key. */
+  rkey: string
+  /** The CID of the version of the record. If not specified, then return the most recent version. */
+  cid?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  uri: string
+  cid?: string
+  value: { [_ in string]: unknown }
+}
+
+export type HandlerInput = undefined
+
+export interface HandlerSuccess {
+  encoding: 'application/json'
+  body: OutputSchema
+  headers?: { [key: string]: string }
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+  error?: 'RecordNotFound'
+}
+
+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

packages/appview/src/lexicons/types/com/atproto/repo/importRepo.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import stream from 'node:stream'
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.importRepo'
+
+export interface QueryParams {}
+
+export type InputSchema = string | Uint8Array | Blob
+
+export interface HandlerInput {
+  encoding: 'application/vnd.ipld.car'
+  body: stream.Readable
+}
+
+export interface HandlerError {
+  status: number
+  message?: string
+}
+
+export type HandlerOutput = HandlerError | void
+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

packages/appview/src/lexicons/types/com/atproto/repo/listMissingBlobs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.listMissingBlobs'
+
+export interface QueryParams {
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  blobs: RecordBlob[]
+}
+
+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
+
+export interface RecordBlob {
+  $type?: 'com.atproto.repo.listMissingBlobs#recordBlob'
+  cid: string
+  recordUri: string
+}
+
+const hashRecordBlob = 'recordBlob'
+
+export function isRecordBlob<V>(v: V) {
+  return is$typed(v, id, hashRecordBlob)
+}
+
+export function validateRecordBlob<V>(v: V) {
+  return validate<RecordBlob & V>(v, id, hashRecordBlob)
+}

packages/appview/src/lexicons/types/com/atproto/repo/listRecords.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.listRecords'
+
+export interface QueryParams {
+  /** The handle or DID of the repo. */
+  repo: string
+  /** The NSID of the record type. */
+  collection: string
+  /** The number of records to return. */
+  limit: number
+  cursor?: string
+  /** DEPRECATED: The lowest sort-ordered rkey to start from (exclusive) */
+  rkeyStart?: string
+  /** DEPRECATED: The highest sort-ordered rkey to stop at (exclusive) */
+  rkeyEnd?: string
+  /** Flag to reverse the order of the returned records. */
+  reverse?: boolean
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  records: Record[]
+}
+
+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
+
+export interface Record {
+  $type?: 'com.atproto.repo.listRecords#record'
+  uri: string
+  cid: string
+  value: { [_ in string]: unknown }
+}
+
+const hashRecord = 'record'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord)
+}

packages/appview/src/lexicons/types/com/atproto/repo/putRecord.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+import type * as ComAtprotoRepoDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.putRecord'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  /** The handle or DID of the repo (aka, current account). */
+  repo: string
+  /** The NSID of the record collection. */
+  collection: string
+  /** The Record Key. */
+  rkey: string
+  /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
+  validate?: boolean
+  /** The record to write. */
+  record: { [_ in string]: unknown }
+  /** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation */
+  swapRecord?: string | null
+  /** Compare and swap with the previous commit by CID. */
+  swapCommit?: string
+}
+
+export interface OutputSchema {
+  uri: string
+  cid: string
+  commit?: ComAtprotoRepoDefs.CommitMeta
+  validationStatus?: 'valid' | 'unknown' | (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
+  error?: 'InvalidSwap'
+}
+
+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

packages/appview/src/lexicons/types/com/atproto/repo/strongRef.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.strongRef'
+
+export interface Main {
+  $type?: 'com.atproto.repo.strongRef'
+  uri: string
+  cid: string
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
+}

packages/appview/src/lexicons/types/com/atproto/repo/uploadBlob.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import stream from 'node:stream'
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.uploadBlob'
+
+export interface QueryParams {}
+
+export type InputSchema = string | Uint8Array | Blob
+
+export interface OutputSchema {
+  blob: BlobRef
+}
+
+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

packages/appview/src/lexicons/types/xyz/statusphere/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.defs'
+
+export interface StatusView {
+  $type?: 'xyz.statusphere.defs#statusView'
+  uri: string
+  status: string
+  createdAt: string
+  profile: ProfileView
+}
+
+const hashStatusView = 'statusView'
+
+export function isStatusView<V>(v: V) {
+  return is$typed(v, id, hashStatusView)
+}
+
+export function validateStatusView<V>(v: V) {
+  return validate<StatusView & V>(v, id, hashStatusView)
+}
+
+export interface ProfileView {
+  $type?: 'xyz.statusphere.defs#profileView'
+  did: string
+  handle: string
+}
+
+const hashProfileView = 'profileView'
+
+export function isProfileView<V>(v: V) {
+  return is$typed(v, id, hashProfileView)
+}
+
+export function validateProfileView<V>(v: V) {
+  return validate<ProfileView & V>(v, id, hashProfileView)
+}

packages/appview/src/lexicons/types/xyz/statusphere/getStatuses.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.getStatuses'
+
+export interface QueryParams {
+  limit: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  statuses: XyzStatusphereDefs.StatusView[]
+}
+
+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

packages/appview/src/lexicons/types/xyz/statusphere/getUser.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as AppBskyActorDefs from '../../app/bsky/actor/defs.js'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.getUser'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  profile: AppBskyActorDefs.ProfileView
+  status?: XyzStatusphereDefs.StatusView
+}
+
+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

packages/appview/src/lexicons/types/xyz/statusphere/sendStatus.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HandlerAuth, HandlerPipeThrough } from '@atproto/xrpc-server'
+import express from 'express'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.sendStatus'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  status: string
+}
+
+export interface OutputSchema {
+  status: XyzStatusphereDefs.StatusView
+}
+
+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

packages/appview/src/lexicons/types/xyz/statusphere/status.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.status'
+
+export interface Record {
+  $type: 'xyz.statusphere.status'
+  status: string
+  createdAt: string
+  [k: string]: unknown
+}
+
+const hashRecord = 'main'
+
+export function isRecord<V>(v: V) {
+  return is$typed(v, id, hashRecord)
+}
+
+export function validateRecord<V>(v: V) {
+  return validate<Record & V>(v, id, hashRecord, true)
+}

packages/appview/src/lexicons/util.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+
+import { ValidationResult } from '@atproto/lexicon'
+
+export type OmitKey<T, K extends keyof T> = {
+  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
+}
+
+export type $Typed<V, T extends string = string> = V & { $type: T }
+export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
+
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main'
+  ? Id
+  : `${Id}#${Hash}`
+
+function isObject<V>(v: V): v is V & object {
+  return v != null && typeof v === 'object'
+}
+
+function is$type<Id extends string, Hash extends string>(
+  $type: unknown,
+  id: Id,
+  hash: Hash,
+): $type is $Type<Id, Hash> {
+  return hash === 'main'
+    ? $type === id
+    : // $type === `${id}#${hash}`
+      typeof $type === 'string' &&
+        $type.length === id.length + 1 + hash.length &&
+        $type.charCodeAt(id.length) === 35 /* '#' */ &&
+        $type.startsWith(id) &&
+        $type.endsWith(hash)
+}
+
+export type $TypedObject<
+  V,
+  Id extends string,
+  Hash extends string,
+> = V extends {
+  $type: $Type<Id, Hash>
+}
+  ? V
+  : V extends { $type?: string }
+    ? V extends { $type?: infer T extends $Type<Id, Hash> }
+      ? V & { $type: T }
+      : never
+    : V & { $type: $Type<Id, Hash> }
+
+export function is$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is $TypedObject<V, Id, Hash> {
+  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)
+}
+
+export function maybe$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is V & object & { $type?: $Type<Id, Hash> } {
+  return (
+    isObject(v) &&
+    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)
+  )
+}
+
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>
+export type ValidatorParam<V extends Validator> =
+  V extends Validator<infer R> ? R : never
+
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export function asPredicate<V extends Validator>(validate: V) {
+  return function <T>(v: T): v is T & ValidatorParam<V> {
+    return validate(v).success
+  }
+}

packages/appview/src/lib/hydrate.ts

···
   XyzStatusphereDefs,
 } from '@statusphere/lexicon'
 
+import { AppContext } from '#/context'
 import { Status } from '#/db'
-import { AppContext } from '#/index'
 
 export async function statusToStatusView(
   status: Status,

packages/appview/src/routes.ts

···
-import type { IncomingMessage, ServerResponse } from 'node:http'
-import { Agent } from '@atproto/api'
-import { TID } from '@atproto/common'
-import { OAuthResolverError } from '@atproto/oauth-client-node'
-import { isValidHandle } from '@atproto/syntax'
-import {
-  AppBskyActorDefs,
-  AppBskyActorProfile,
-  XyzStatusphereStatus,
-} from '@statusphere/lexicon'
-import express from 'express'
-import { getIronSession, SessionOptions } from 'iron-session'
-
-import type { AppContext } from '#/index'
-import { env } from '#/lib/env'
-import { bskyProfileToProfileView, statusToStatusView } from '#/lib/hydrate'
-
-type Session = { did: string }
-
-// Common session options
-const sessionOptions: SessionOptions = {
-  cookieName: 'sid',
-  password: env.COOKIE_SECRET,
-  cookieOptions: {
-    secure: env.NODE_ENV === 'production',
-    httpOnly: true,
-    sameSite: true,
-    path: '/',
-    // Don't set domain explicitly - let browser determine it
-    domain: undefined,
-  },
-}
-
-// Helper function for defining routes
-const handler =
-  (
-    fn: (
-      req: express.Request,
-      res: express.Response,
-      next: express.NextFunction,
-    ) => Promise<void> | void,
-  ) =>
-  async (
-    req: express.Request,
-    res: express.Response,
-    next: express.NextFunction,
-  ) => {
-    try {
-      await fn(req, res, next)
-    } catch (err) {
-      next(err)
-    }
-  }
-
-// Helper function to get the Atproto Agent for the active session
-async function getSessionAgent(
-  req: IncomingMessage | express.Request,
-  res: ServerResponse<IncomingMessage> | express.Response,
-  ctx: AppContext,
-) {
-  const session = await getIronSession<Session>(req, res, sessionOptions)
-
-  if (!session.did) {
-    return null
-  }
-
-  try {
-    const oauthSession = await ctx.oauthClient.restore(session.did)
-    return oauthSession ? new Agent(oauthSession) : null
-  } catch (err) {
-    ctx.logger.warn({ err }, 'oauth restore failed')
-    session.destroy()
-    return null
-  }
-}
-
-export const createRouter = (ctx: AppContext) => {
-  const router = express.Router()
-
-  // Simple CORS configuration for all routes
-  router.use((req, res, next) => {
-    // Allow requests from either the specific origin or any origin during development
-    res.header('Access-Control-Allow-Origin', req.headers.origin || '*')
-    res.header('Access-Control-Allow-Credentials', 'true')
-    res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
-    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization')
-
-    if (req.method === 'OPTIONS') {
-      res.status(200).end()
-      return
-    }
-    next()
-  })
-
-  // OAuth metadata
-  router.get(
-    '/client-metadata.json',
-    handler((_req, res) => {
-      res.json(ctx.oauthClient.clientMetadata)
-    }),
-  )
-
-  // OAuth callback to complete session creation
-  router.get(
-    '/oauth/callback',
-    handler(async (req, res) => {
-      // Get the query parameters from the URL
-      const params = new URLSearchParams(req.originalUrl.split('?')[1])
-
-      try {
-        const { session } = await ctx.oauthClient.callback(params)
-
-        // Use the common session options
-        const clientSession = await getIronSession<Session>(
-          req,
-          res,
-          sessionOptions,
-        )
-
-        // Set the DID on the session
-        clientSession.did = session.did
-        await clientSession.save()
-
-        // Get the origin and determine appropriate redirect
-        const host = req.get('host') || ''
-        const protocol = req.protocol || 'http'
-        const baseUrl = `${protocol}://${host}`
-
-        ctx.logger.info(
-          `OAuth callback successful, redirecting to ${baseUrl}/oauth-callback`,
-        )
-
-        // Redirect to the frontend oauth-callback page
-        res.redirect('/oauth-callback')
-      } catch (err) {
-        ctx.logger.error({ err }, 'oauth callback failed')
-
-        // Handle error redirect - stay on same domain
-        res.redirect('/oauth-callback?error=auth')
-      }
-    }),
-  )
-
-  // Login handler
-  router.post(
-    '/login',
-    handler(async (req, res) => {
-      // Validate
-      const handle = req.body?.handle
-      if (typeof handle !== 'string' || !isValidHandle(handle)) {
-        res.status(400).json({ error: 'invalid handle' })
-        return
-      }
-
-      // Initiate the OAuth flow
-      try {
-        const url = await ctx.oauthClient.authorize(handle, {
-          scope: 'atproto transition:generic',
-        })
-        res.json({ redirectUrl: url.toString() })
-      } catch (err) {
-        ctx.logger.error({ err }, 'oauth authorize failed')
-        const errorMsg =
-          err instanceof OAuthResolverError
-            ? err.message
-            : "couldn't initiate login"
-        res.status(500).json({ error: errorMsg })
-      }
-    }),
-  )
-
-  // Logout handler
-  router.post(
-    '/logout',
-    handler(async (req, res) => {
-      const session = await getIronSession<Session>(req, res, sessionOptions)
-      session.destroy()
-      res.json({ success: true })
-    }),
-  )
-
-  // Get current user info
-  router.get(
-    '/user',
-    handler(async (req, res) => {
-      const agent = await getSessionAgent(req, res, ctx)
-      if (!agent) {
-        res.status(401).json({ error: 'Not logged in' })
-        return
-      }
-
-      const did = agent.assertDid
-
-      // Fetch user profile
-      try {
-        const profileResponse = await agent.com.atproto.repo
-          .getRecord({
-            repo: did,
-            collection: 'app.bsky.actor.profile',
-            rkey: 'self',
-          })
-          .catch(() => undefined)
-
-        const profileRecord = profileResponse?.data
-        let profile: AppBskyActorProfile.Record =
-          {} as AppBskyActorProfile.Record
-
-        if (
-          profileRecord &&
-          AppBskyActorProfile.isRecord(profileRecord.value)
-        ) {
-          const validated = AppBskyActorProfile.validateRecord(
-            profileRecord.value,
-          )
-          if (validated.success) {
-            profile = profileRecord.value
-          } else {
-            ctx.logger.error(
-              { err: validated.error },
-              'Failed to validate user profile',
-            )
-          }
-        }
-
-        // Fetch user status
-        const status = await ctx.db
-          .selectFrom('status')
-          .selectAll()
-          .where('authorDid', '=', did)
-          .orderBy('indexedAt', 'desc')
-          .executeTakeFirst()
-
-        res.json({
-          did: agent.assertDid,
-          profile: await bskyProfileToProfileView(did, profile, ctx),
-          status: status ? await statusToStatusView(status, ctx) : undefined,
-        })
-      } catch (err) {
-        ctx.logger.error({ err }, 'Failed to get user info')
-        res.status(500).json({ error: 'Failed to get user info' })
-      }
-    }),
-  )
-
-  // Get statuses
-  router.get(
-    '/statuses',
-    handler(async (req, res) => {
-      try {
-        // Fetch data stored in our SQLite
-        const statuses = await ctx.db
-          .selectFrom('status')
-          .selectAll()
-          .orderBy('indexedAt', 'desc')
-          .limit(30)
-          .execute()
-
-        res.json({
-          statuses: await Promise.all(
-            statuses.map((status) => statusToStatusView(status, ctx)),
-          ),
-        })
-      } catch (err) {
-        ctx.logger.error({ err }, 'Failed to get statuses')
-        res.status(500).json({ error: 'Failed to get statuses' })
-      }
-    }),
-  )
-
-  // Create status
-  router.post(
-    '/status',
-    handler(async (req, res) => {
-      // If the user is signed in, get an agent which communicates with their server
-      const agent = await getSessionAgent(req, res, ctx)
-      if (!agent) {
-        res.status(401).json({ error: 'Session required' })
-        return
-      }
-
-      // Construct & validate their status record
-      const rkey = TID.nextStr()
-      const record = {
-        $type: 'xyz.statusphere.status',
-        status: req.body?.status,
-        createdAt: new Date().toISOString(),
-      }
-      if (!XyzStatusphereStatus.validateRecord(record).success) {
-        res.status(400).json({ error: 'Invalid status' })
-        return
-      }
-
-      let uri
-      try {
-        // Write the status record to the user's repository
-        const response = await agent.com.atproto.repo.putRecord({
-          repo: agent.assertDid,
-          collection: 'xyz.statusphere.status',
-          rkey,
-          record,
-          validate: false,
-        })
-        uri = response.data.uri
-      } catch (err) {
-        ctx.logger.warn({ err }, 'failed to write record')
-        res.status(500).json({ error: 'Failed to write record' })
-        return
-      }
-
-      try {
-        // Optimistically update our SQLite
-        // This isn't strictly necessary because the write event will be
-        // handled in #/firehose/ingestor.ts, but it ensures that future reads
-        // will be up-to-date after this method finishes.
-        await ctx.db
-          .insertInto('status')
-          .values({
-            uri,
-            authorDid: agent.assertDid,
-            status: record.status,
-            createdAt: record.createdAt,
-            indexedAt: new Date().toISOString(),
-          })
-          .execute()
-
-        res.json({
-          success: true,
-          uri,
-          status: await statusToStatusView(record.status, ctx),
-        })
-      } catch (err) {
-        ctx.logger.warn(
-          { err },
-          'failed to update computed view; ignoring as it should be caught by the firehose',
-        )
-        res.json({
-          success: true,
-          uri,
-          status: await statusToStatusView(record.status, ctx),
-          warning: 'Database not updated',
-        })
-      }
-    }),
-  )
-
-  return router
-}

packages/appview/src/session.ts

···
+import { IncomingMessage, ServerResponse } from 'node:http'
+import { Agent } from '@atproto/api'
+import { Request, Response } from 'express'
+import { getIronSession, SessionOptions } from 'iron-session'
+
+import { AppContext } from '#/context'
+import { env } from '#/lib/env'
+
+type Session = { did: string }
+
+// Common session options
+const sessionOptions: SessionOptions = {
+  cookieName: 'sid',
+  password: env.COOKIE_SECRET,
+  cookieOptions: {
+    secure: env.NODE_ENV === 'production',
+    httpOnly: true,
+    sameSite: true,
+    path: '/',
+    // Don't set domain explicitly - let browser determine it
+    domain: undefined,
+  },
+}
+
+export async function getSessionAgent(
+  req: IncomingMessage | Request,
+  res: ServerResponse<IncomingMessage> | Response,
+  ctx: AppContext,
+) {
+  const session = await getIronSession<Session>(req, res, sessionOptions)
+
+  if (!session.did) {
+    return null
+  }
+
+  try {
+    const oauthSession = await ctx.oauthClient.restore(session.did)
+    return oauthSession ? new Agent(oauthSession) : null
+  } catch (err) {
+    ctx.logger.warn({ err }, 'oauth restore failed')
+    session.destroy()
+    return null
+  }
+}
+
+export async function getSession(req: Request, res: Response) {
+  return getIronSession<Session>(req, res, sessionOptions)
+}

packages/client/package.json

···
   },
   "dependencies": {
     "@atproto/api": "^0.14.7",
+    "@atproto/xrpc": "^0.6.9",
     "@statusphere/lexicon": "workspace:*",
     "@tailwindcss/vite": "^4.0.9",
     "@tanstack/react-query": "^5.66.11",

packages/client/src/components/StatusForm.tsx

···
 
   // Use React Query mutation for creating a status
   const mutation = useMutation({
-    mutationFn: (emoji: string) => api.createStatus(emoji),
+    mutationFn: (emoji: string) => api.createStatus({ status: emoji }),
     onMutate: async (emoji) => {
       // Cancel any outgoing refetches so they don't overwrite our optimistic updates
       await queryClient.cancelQueries({ queryKey: ['statuses'] })
···
         const optimisticStatus = {
           uri: `optimistic-${Date.now()}`,
           profile: {
-            did: user.did,
+            did: user.profile.did,
             handle: user.profile.handle,
           },
           status: emoji,

packages/client/src/components/StatusList.tsx

···
+import { useEffect } from 'react'
 import { useQuery } from '@tanstack/react-query'
 
 import api from '#/services/api'
···
   const { data, isPending, isError, error } = useQuery({
     queryKey: ['statuses'],
     queryFn: async () => {
-      const data = await api.getStatuses()
+      const { data } = await api.getStatuses({ limit: 30 })
       return data
     },
     placeholderData: (previousData) => previousData, // Use previous data while refetching
     refetchInterval: 30e3, // Refetch every 30 seconds
   })
+
+  useEffect(() => {
+    if (error) {
+      console.error(error)
+    }
+  }, [error])
 
   // Destructure data
   const statuses = data?.statuses || []

packages/client/src/hooks/useAuth.tsx

···
 import { createContext, ReactNode, useContext, useState } from 'react'
 import { useQuery, useQueryClient } from '@tanstack/react-query'
+import { XRPCError } from '@atproto/xrpc'
+import { XyzStatusphereGetUser } from '@statusphere/lexicon'
 
-import api, { User } from '#/services/api'
+import api from '#/services/api'
 
 interface AuthContextType {
-  user: User | null
+  user: XyzStatusphereGetUser.OutputSchema | null
   loading: boolean
   error: string | null
   login: (handle: string) => Promise<{ redirectUrl: string }>
···
       }
 
       try {
-        const userData = await api.getCurrentUser()
+        const { data: userData } = await api.getCurrentUser({})
 
         // Clean up URL if needed
         if (window.location.search && userData) {
···
 
         return userData
       } catch (apiErr) {
+        if (
+          apiErr instanceof XRPCError &&
+          apiErr.error === 'AuthenticationRequired'
+        ) {
+          return null
+        }
+
         console.error('🚫 API error during auth check:', apiErr)
 
         // If it's a network error, provide a more helpful message
···
     setError(null)
 
     try {
-      // Add a small artificial delay for UX purposes
-      const loginPromise = api.login(handle)
-
-      // Ensure the loading state shows for at least 800ms for better UX
-      const result = await Promise.all([
-        loginPromise,
-        new Promise((resolve) => setTimeout(resolve, 800)),
-      ]).then(([loginResult]) => loginResult)
-
-      return result
+      return await api.login(handle)
     } catch (err) {
       const message = err instanceof Error ? err.message : 'Login failed'
       setError(message)

packages/client/src/pages/OAuthCallbackPage.tsx

···
               .join(', '),
           )
 
-          const user = await api.getCurrentUser()
+          const user = await api.getCurrentUser({})
           console.log('Current user check result:', user)
 
           if (user) {

packages/client/src/services/api.ts

···
-import { AppBskyActorDefs, XyzStatusphereDefs } from '@statusphere/lexicon'
+import * as Lexicon from '@statusphere/lexicon'
+import type {
+  XyzStatusphereGetStatuses,
+  XyzStatusphereGetUser,
+  XyzStatusphereSendStatus,
+} from '@statusphere/lexicon'
 
-// Use '/api' prefix consistently for all API calls
-const API_URL = '/api'
+class StatusphereAgent extends Lexicon.AtpBaseClient {
+  constructor() {
+    super(StatusphereAgent.fetchHandler)
+  }
 
-// Helper function for logging API actions
-function logApiCall(
-  method: string,
-  endpoint: string,
-  status?: number,
-  error?: any,
-) {
-  const statusStr = status ? `[${status}]` : ''
-  const errorStr = error
-    ? ` - Error: ${error.message || JSON.stringify(error)}`
-    : ''
-  console.log(`🔄 API ${method} ${endpoint} ${statusStr}${errorStr}`)
+  private static fetchHandler: Lexicon.AtpBaseClient['fetchHandler'] = async (
+    path,
+    options,
+  ) => {
+    return await fetch(path, {
+      ...options,
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      credentials: 'include',
+    })
+  }
 }
 
-export interface User {
-  did: string
-  profile: AppBskyActorDefs.ProfileView
-  status?: XyzStatusphereDefs.StatusView
-}
+const agent = new StatusphereAgent()
 
 // API service
 export const api = {
   // Login
   async login(handle: string) {
-    const url = `${API_URL}/login`
-    logApiCall('POST', url)
-
-    const response = await fetch(url, {
+    const response = await fetch('/oauth/initiate', {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
···
 
   // Logout
   async logout() {
-    const url = `${API_URL}/logout`
-    logApiCall('POST', url)
-    const response = await fetch(url, {
+    const response = await fetch('/oauth/logout', {
       method: 'POST',
       credentials: 'include',
     })
···
   },
 
   // Get current user
-  async getCurrentUser() {
-    const url = `${API_URL}/user`
-    logApiCall('GET', url)
-    try {
-      const headers = {
-        Accept: 'application/json',
-      }
-
-      const response = await fetch(url, {
-        credentials: 'include', // This is crucial for sending cookies
-        headers,
-        cache: 'no-cache', // Don't cache this request
-      })
-
-      logApiCall('GET', '/user', response.status)
-
-      if (!response.ok) {
-        if (response.status === 401) {
-          return null
-        }
-
-        // Try to get error details
-        let errorText = ''
-        try {
-          const errorData = await response.text()
-          errorText = errorData
-        } catch (e) {
-          // Ignore error reading error
-        }
-
-        throw new Error(
-          `Failed to get user: ${response.status} ${response.statusText} ${errorText}`,
-        )
-      }
-
-      return response.json()
-    } catch (error) {
-      logApiCall('GET', '/user', undefined, error)
-      if (
-        error instanceof TypeError &&
-        error.message.includes('Failed to fetch')
-      ) {
-        console.error('Network error - Unable to connect to API server')
-      }
-      throw error
-    }
+  async getCurrentUser(params: XyzStatusphereGetUser.QueryParams) {
+    return agent.xyz.statusphere.getUser(params)
   },
 
   // Get statuses
-  async getStatuses() {
-    const url = `${API_URL}/statuses`
-    logApiCall('GET', url)
-    const response = await fetch(url, {
-      credentials: 'include',
-    })
-
-    if (!response.ok) {
-      throw new Error('Failed to get statuses')
-    }
-
-    return response.json() as Promise<{
-      statuses: XyzStatusphereDefs.StatusView[]
-    }>
+  async getStatuses(params: XyzStatusphereGetStatuses.QueryParams) {
+    return agent.xyz.statusphere.getStatuses(params)
   },
 
   // Create status
-  async createStatus(status: string) {
-    const url = `${API_URL}/status`
-    logApiCall('POST', url)
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      credentials: 'include',
-      body: JSON.stringify({ status }),
-    })
-
-    if (!response.ok) {
-      const error = await response.json()
-      throw new Error(error.error || 'Failed to create status')
-    }
-
-    return response.json()
+  async createStatus(params: XyzStatusphereSendStatus.InputSchema) {
+    return agent.xyz.statusphere.sendStatus(params)
   },
 }
 

packages/client/vite.config.ts

···
     host: '127.0.0.1',
     port: 3000,
     proxy: {
-      '/api': {
+      '^/(xrpc|oauth|client-metadata\.json)/.*': {
         target: 'http://localhost:3001',
         changeOrigin: true,
       },

packages/lexicon/package.json

···
   "author": "",
   "license": "MIT",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
   "private": true,
   "scripts": {
     "build": "pnpm lexgen && tsup",

packages/lexicon/src/index.ts

···
 import * as ComAtprotoRepoStrongRef from './types/com/atproto/repo/strongRef.js'
 import * as ComAtprotoRepoUploadBlob from './types/com/atproto/repo/uploadBlob.js'
 import * as XyzStatusphereDefs from './types/xyz/statusphere/defs.js'
+import * as XyzStatusphereGetStatuses from './types/xyz/statusphere/getStatuses.js'
+import * as XyzStatusphereGetUser from './types/xyz/statusphere/getUser.js'
+import * as XyzStatusphereSendStatus from './types/xyz/statusphere/sendStatus.js'
 import * as XyzStatusphereStatus from './types/xyz/statusphere/status.js'
 import { OmitKey, Un$Typed } from './util.js'
 
 export * as XyzStatusphereDefs from './types/xyz/statusphere/defs.js'
+export * as XyzStatusphereGetStatuses from './types/xyz/statusphere/getStatuses.js'
+export * as XyzStatusphereGetUser from './types/xyz/statusphere/getUser.js'
+export * as XyzStatusphereSendStatus from './types/xyz/statusphere/sendStatus.js'
 export * as XyzStatusphereStatus from './types/xyz/statusphere/status.js'
 export * as ComAtprotoLabelDefs from './types/com/atproto/label/defs.js'
 export * as ComAtprotoRepoApplyWrites from './types/com/atproto/repo/applyWrites.js'
···
   constructor(client: XrpcClient) {
     this._client = client
     this.status = new StatusRecord(client)
+  }
+
+  getStatuses(
+    params?: XyzStatusphereGetStatuses.QueryParams,
+    opts?: XyzStatusphereGetStatuses.CallOptions,
+  ): Promise<XyzStatusphereGetStatuses.Response> {
+    return this._client.call(
+      'xyz.statusphere.getStatuses',
+      params,
+      undefined,
+      opts,
+    )
+  }
+
+  getUser(
+    params?: XyzStatusphereGetUser.QueryParams,
+    opts?: XyzStatusphereGetUser.CallOptions,
+  ): Promise<XyzStatusphereGetUser.Response> {
+    return this._client.call('xyz.statusphere.getUser', params, undefined, opts)
+  }
+
+  sendStatus(
+    data?: XyzStatusphereSendStatus.InputSchema,
+    opts?: XyzStatusphereSendStatus.CallOptions,
+  ): Promise<XyzStatusphereSendStatus.Response> {
+    return this._client.call('xyz.statusphere.sendStatus', opts?.qp, data, opts)
   }
 }
 

packages/lexicon/src/lexicons.ts

···
       },
     },
   },
+  XyzStatusphereGetStatuses: {
+    lexicon: 1,
+    id: 'xyz.statusphere.getStatuses',
+    defs: {
+      main: {
+        type: 'query',
+        description: 'Get a list of the most recent statuses on the network.',
+        parameters: {
+          type: 'params',
+          properties: {
+            limit: {
+              type: 'integer',
+              minimum: 1,
+              maximum: 100,
+              default: 50,
+            },
+            cursor: {
+              type: 'string',
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['statuses'],
+            properties: {
+              cursor: {
+                type: 'string',
+              },
+              statuses: {
+                type: 'array',
+                items: {
+                  type: 'ref',
+                  ref: 'lex:xyz.statusphere.defs#statusView',
+                },
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereGetUser: {
+    lexicon: 1,
+    id: 'xyz.statusphere.getUser',
+    defs: {
+      main: {
+        type: 'query',
+        description: "Get the current user's profile and status.",
+        parameters: {
+          type: 'params',
+          properties: {},
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['profile'],
+            properties: {
+              profile: {
+                type: 'ref',
+                ref: 'lex:app.bsky.actor.defs#profileView',
+              },
+              status: {
+                type: 'ref',
+                ref: 'lex:xyz.statusphere.defs#statusView',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
+  XyzStatusphereSendStatus: {
+    lexicon: 1,
+    id: 'xyz.statusphere.sendStatus',
+    defs: {
+      main: {
+        type: 'procedure',
+        description: 'Send a status into the ATmosphere.',
+        input: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['status'],
+            properties: {
+              status: {
+                type: 'string',
+                minLength: 1,
+                maxGraphemes: 1,
+                maxLength: 32,
+              },
+            },
+          },
+        },
+        output: {
+          encoding: 'application/json',
+          schema: {
+            type: 'object',
+            required: ['status'],
+            properties: {
+              status: {
+                type: 'ref',
+                ref: 'lex:xyz.statusphere.defs#statusView',
+              },
+            },
+          },
+        },
+      },
+    },
+  },
   XyzStatusphereStatus: {
     lexicon: 1,
     id: 'xyz.statusphere.status',
···
 
 export const ids = {
   XyzStatusphereDefs: 'xyz.statusphere.defs',
+  XyzStatusphereGetStatuses: 'xyz.statusphere.getStatuses',
+  XyzStatusphereGetUser: 'xyz.statusphere.getUser',
+  XyzStatusphereSendStatus: 'xyz.statusphere.sendStatus',
   XyzStatusphereStatus: 'xyz.statusphere.status',
   ComAtprotoLabelDefs: 'com.atproto.label.defs',
   ComAtprotoRepoApplyWrites: 'com.atproto.repo.applyWrites',

packages/lexicon/src/types/xyz/statusphere/getStatuses.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.getStatuses'
+
+export interface QueryParams {
+  limit?: number
+  cursor?: string
+}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  cursor?: string
+  statuses: XyzStatusphereDefs.StatusView[]
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

packages/lexicon/src/types/xyz/statusphere/getUser.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as AppBskyActorDefs from '../../app/bsky/actor/defs.js'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.getUser'
+
+export interface QueryParams {}
+
+export type InputSchema = undefined
+
+export interface OutputSchema {
+  profile: AppBskyActorDefs.ProfileView
+  status?: XyzStatusphereDefs.StatusView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

packages/lexicon/src/types/xyz/statusphere/sendStatus.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { BlobRef, ValidationResult } from '@atproto/lexicon'
+import { HeadersMap, XRPCError } from '@atproto/xrpc'
+import { CID } from 'multiformats/cid'
+
+import { validate as _validate } from '../../../lexicons'
+import { is$typed as _is$typed, $Typed, OmitKey } from '../../../util'
+import type * as XyzStatusphereDefs from './defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'xyz.statusphere.sendStatus'
+
+export interface QueryParams {}
+
+export interface InputSchema {
+  status: string
+}
+
+export interface OutputSchema {
+  status: XyzStatusphereDefs.StatusView
+}
+
+export interface CallOptions {
+  signal?: AbortSignal
+  headers?: HeadersMap
+  qp?: QueryParams
+  encoding?: 'application/json'
+}
+
+export interface Response {
+  success: boolean
+  headers: HeadersMap
+  data: OutputSchema
+}
+
+export function toKnownErr(e: any) {
+  return e
+}

pnpm-lock.yaml

···
       better-sqlite3:
         specifier: ^11.8.1
         version: 11.8.1
+      compression:
+        specifier: ^1.8.0
+        version: 1.8.0
       cors:
         specifier: ^2.8.5
         version: 2.8.5
···
         specifier: ^9.6.0
         version: 9.6.0
     devDependencies:
+      '@atproto/lex-cli':
+        specifier: ^0.6.1
+        version: 0.6.1
       '@types/better-sqlite3':
         specifier: ^7.6.12
         version: 7.6.12
+      '@types/compression':
+        specifier: ^1.7.5
+        version: 1.7.5
       '@types/cors':
         specifier: ^2.8.17
         version: 2.8.17
···
       '@atproto/api':
         specifier: ^0.14.7
         version: 0.14.7
+      '@atproto/xrpc':
+        specifier: ^0.6.9
+        version: 0.6.9
       '@statusphere/lexicon':
         specifier: workspace:*
         version: link:../lexicon
···
   '@types/body-parser@1.19.5':
     resolution: {integrity: sha512-fB3Zu92ucau0iQ0JMCFQE7b/dv8Ot07NI3KaZIkIUNXq82k4eBAqUaneXfleGY9JWskeS9y+u0nXMyspcuQrCg==}
 
+  '@types/compression@1.7.5':
+    resolution: {integrity: sha512-AAQvK5pxMpaT+nDvhHrsBhLSYG5yQdtkaJE1WYieSNY2mVFKAgmU4ks65rkZD5oqnGCFLyQpUr1CqI4DmUMyDg==}
+
   '@types/connect@3.4.38':
     resolution: {integrity: sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug==}
 
···
   commander@9.5.0:
     resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
     engines: {node: ^12.20.0 || >=14}
+
+  compressible@2.0.18:
+    resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==}
+    engines: {node: '>= 0.6'}
+
+  compression@1.8.0:
+    resolution: {integrity: sha512-k6WLKfunuqCYD3t6AsuPGvQWaKwuLLh2/xHNcX4qE+vIfDNXpSqnrhwA7O53R7WVQUnt8dVAIW+YHr7xTgOgGA==}
+    engines: {node: '>= 0.8.0'}
 
   concat-map@0.0.1:
     resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
···
     resolution: {integrity: sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==}
     engines: {node: '>= 0.6'}
 
+  negotiator@0.6.4:
+    resolution: {integrity: sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==}
+    engines: {node: '>= 0.6'}
+
   node-abi@3.74.0:
     resolution: {integrity: sha512-c5XK0MjkGBrQPGYG24GBADZud0NCbznxNx0ZkS+ebUTrmV1qTDxPxSL8zEAPURXSbLRWVexxmP4986BziahL5w==}
     engines: {node: '>=10'}
···
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
     engines: {node: '>= 0.8'}
 
+  on-headers@1.0.2:
+    resolution: {integrity: sha512-pZAE+FJLoyITytdqK0U5s+FIpjN0JP3OzFi/u8Rx+EV5/W+JTWGXG8xFzevE7AjBfDqHv/8vL8qQsIhHnqRkrA==}
+    engines: {node: '>= 0.8'}
+
   once@1.4.0:
     resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
 
···
       '@types/connect': 3.4.38
       '@types/node': 22.13.8
 
+  '@types/compression@1.7.5':
+    dependencies:
+      '@types/express': 5.0.0
+
   '@types/connect@3.4.38':
     dependencies:
       '@types/node': 22.13.8
···
   commander@4.1.1: {}
 
   commander@9.5.0: {}
+
+  compressible@2.0.18:
+    dependencies:
+      mime-db: 1.52.0
+
+  compression@1.8.0:
+    dependencies:
+      bytes: 3.1.2
+      compressible: 2.0.18
+      debug: 2.6.9
+      negotiator: 0.6.4
+      on-headers: 1.0.2
+      safe-buffer: 5.2.1
+      vary: 1.1.2
+    transitivePeerDependencies:
+      - supports-color
 
   concat-map@0.0.1: {}
 
···
 
   negotiator@0.6.3: {}
 
+  negotiator@0.6.4: {}
+
   node-abi@3.74.0:
     dependencies:
       semver: 7.7.1
···
   on-finished@2.4.1:
     dependencies:
       ee-first: 1.1.1
+
+  on-headers@1.0.2: {}
 
   once@1.4.0:
     dependencies: