@atproto/pds 0.4.216 → 0.4.217

package/src/context.ts

@@ -5,10 +5,10 @@ import { Redis } from 'ioredis'
 import * as nodemailer from 'nodemailer'
 import * as ui8 from 'uint8arrays'
 import * as undici from 'undici'
-import { AtpAgent } from '@atproto/api'
 import { KmsKeypair, S3BlobStore } from '@atproto/aws'
 import * as crypto from '@atproto/crypto'
 import { IdResolver } from '@atproto/identity'
+import { Client } from '@atproto/lex'
 import {
   AccessTokenMode,
   JoseKey,
@@ -66,10 +66,10 @@ export type AppContextOptions = {
   redisScratch?: Redis
   crawlers: Crawlers
   bskyAppView?: BskyAppView
-  moderationAgent?: AtpAgent
-  reportingAgent?: AtpAgent
-  entrywayAgent?: AtpAgent
-  entrywayAdminAgent?: AtpAgent
+  moderationClient?: Client
+  reportingClient?: Client
+  entrywayClient?: Client
+  entrywayAdminClient?: Client
   proxyAgent: undici.Dispatcher
   safeFetch: Fetch
   oauthProvider?: OAuthProvider
@@ -93,10 +93,10 @@ export class AppContext {
   public redisScratch?: Redis
   public crawlers: Crawlers
   public bskyAppView?: BskyAppView
-  public moderationAgent: AtpAgent | undefined
-  public reportingAgent: AtpAgent | undefined
-  public entrywayAgent: AtpAgent | undefined
-  public entrywayAdminAgent: AtpAgent | undefined
+  public moderationClient: Client | undefined
+  public reportingClient: Client | undefined
+  public entrywayClient: Client | undefined
+  public entrywayAdminClient: Client | undefined
   public proxyAgent: undici.Dispatcher
   public safeFetch: Fetch
   public authVerifier: AuthVerifier
@@ -119,10 +119,10 @@ export class AppContext {
     this.redisScratch = opts.redisScratch
     this.crawlers = opts.crawlers
     this.bskyAppView = opts.bskyAppView
-    this.moderationAgent = opts.moderationAgent
-    this.reportingAgent = opts.reportingAgent
-    this.entrywayAgent = opts.entrywayAgent
-    this.entrywayAdminAgent = opts.entrywayAdminAgent
+    this.moderationClient = opts.moderationClient
+    this.reportingClient = opts.reportingClient
+    this.entrywayClient = opts.entrywayClient
+    this.entrywayAdminClient = opts.entrywayAdminClient
     this.proxyAgent = opts.proxyAgent
     this.safeFetch = opts.safeFetch
     this.authVerifier = opts.authVerifier
@@ -183,9 +183,9 @@ export class AppContext {
 
     const backgroundQueue = new BackgroundQueue()
     const crawlers = new Crawlers(
+      backgroundQueue,
       cfg.service.hostname,
       cfg.crawlers,
-      backgroundQueue,
     )
     const sequencer = new Sequencer(
       cfg.db.sequencerDbLoc,
@@ -198,26 +198,59 @@ export class AppContext {
       : undefined
 
     const bskyAppView = cfg.bskyAppView
-      ? new BskyAppView(cfg.bskyAppView)
+      ? new BskyAppView({
+          ...cfg.bskyAppView,
+          validateResponse: cfg.service.devMode,
+        })
       : undefined
 
-    const moderationAgent = cfg.modService
-      ? new AtpAgent({ service: cfg.modService.url })
+    const moderationClient = cfg.modService
+      ? new Client(
+          { service: cfg.modService.url },
+          {
+            // Trust internal services to send us well-formed responses
+            strictResponseProcessing: false,
+            validateResponse: cfg.service.devMode,
+          },
+        )
       : undefined
-    const reportingAgent = cfg.reportService
-      ? new AtpAgent({ service: cfg.reportService.url })
+    const reportingClient = cfg.reportService
+      ? new Client(
+          { service: cfg.reportService.url },
+          {
+            // Trust internal services to send us well-formed responses
+            strictResponseProcessing: false,
+            validateResponse: cfg.service.devMode,
+          },
+        )
       : undefined
-    const entrywayAgent = cfg.entryway
-      ? new AtpAgent({ service: cfg.entryway.url })
+    const entrywayClient = cfg.entryway
+      ? new Client(
+          { service: cfg.entryway.url },
+          {
+            // Trust internal services to send us well-formed responses
+            strictResponseProcessing: false,
+            validateResponse: cfg.service.devMode,
+          },
+        )
       : undefined
-    let entrywayAdminAgent: AtpAgent | undefined
-    if (cfg.entryway && secrets.entrywayAdminToken) {
-      entrywayAdminAgent = new AtpAgent({ service: cfg.entryway.url })
-      entrywayAdminAgent.api.setHeader(
-        'authorization',
-        basicAuthHeader('admin', secrets.entrywayAdminToken),
-      )
-    }
+    const entrywayAdminClient =
+      cfg.entryway && secrets.entrywayAdminToken
+        ? new Client(
+            { service: cfg.entryway.url },
+            {
+              headers: {
+                authorization: basicAuthHeader(
+                  'admin',
+                  secrets.entrywayAdminToken,
+                ),
+              },
+              // Trust internal services to send us well-formed responses
+              strictResponseProcessing: false,
+              validateResponse: cfg.service.devMode,
+            },
+          )
+        : undefined
 
     const jwtSecretKey = createSecretKeyObject(secrets.jwtSecret)
     const jwtPublicKey = cfg.entryway
@@ -404,8 +437,8 @@ export class AppContext {
         })
       : undefined
 
-    const scopeRefGetter = entrywayAgent
-      ? new ScopeReferenceGetter(entrywayAgent, redisScratch)
+    const scopeRefGetter = entrywayClient
+      ? new ScopeReferenceGetter(entrywayClient, redisScratch)
       : undefined
 
     const oauthVerifier: OAuthVerifier =
@@ -464,10 +497,10 @@ export class AppContext {
       redisScratch,
       crawlers,
       bskyAppView,
-      moderationAgent,
-      reportingAgent,
-      entrywayAgent,
-      entrywayAdminAgent,
+      moderationClient,
+      reportingClient,
+      entrywayClient,
+      entrywayAdminClient,
       proxyAgent,
       safeFetch,
       authVerifier,

package/src/crawlers.ts

@@ -1,44 +1,46 @@
-import { AtpAgent } from '@atproto/api'
-import { MINUTE } from '@atproto/common'
-import { BackgroundQueue } from './background'
-import { crawlerLogger as log } from './logger'
+import { xrpc } from '@atproto/lex'
+import { BackgroundQueue } from './background.js'
+import { com } from './lexicons/index.js'
+import { crawlerLogger as log } from './logger.js'
 
-const NOTIFY_THRESHOLD = 20 * MINUTE
+const NOTIFY_THRESHOLD = 20 * 60e3
 
 export class Crawlers {
-  public agents: AtpAgent[]
-  public lastNotified = 0
+  private lastNotified = -Infinity
 
   constructor(
-    public hostname: string,
-    public crawlers: string[],
-    public backgroundQueue: BackgroundQueue,
-  ) {
-    this.agents = crawlers.map((service) => new AtpAgent({ service }))
-  }
+    private readonly backgroundQueue: BackgroundQueue,
+    private readonly hostname: string,
+    private readonly crawlers: Iterable<string>,
+  ) {}
 
-  async notifyOfUpdate() {
+  notifyOfUpdate() {
     const now = Date.now()
-    if (now - this.lastNotified < NOTIFY_THRESHOLD) {
-      return
+    if (this.lastNotified < now - NOTIFY_THRESHOLD) {
+      this.lastNotified = now
+      this.requestCrawl()
+    } else {
+      // @TODO We should probably actually schedule (setTimeout) a crawl for
+      // when the threshold is met, instead of just waiting for the next update
+      // to trigger it. Not doing this now as it requires cleanup logic on
+      // shutdown.
     }
+  }
 
-    this.backgroundQueue.add(async () => {
-      await Promise.all(
-        this.agents.map(async (agent) => {
-          try {
-            await agent.api.com.atproto.sync.requestCrawl({
-              hostname: this.hostname,
-            })
-          } catch (err) {
-            log.warn(
-              { err, cralwer: agent.service.toString() },
-              'failed to request crawl',
-            )
-          }
-        }),
-      )
-      this.lastNotified = now
-    })
+  private requestCrawl() {
+    for (const crawler of this.crawlers) {
+      this.backgroundQueue.add(async () => {
+        try {
+          await xrpc(crawler, com.atproto.sync.requestCrawl, {
+            validateRequest: false,
+            validateResponse: false,
+            strictResponseProcessing: false,
+            body: { hostname: this.hostname },
+          })
+        } catch (err) {
+          log.warn({ err, crawler }, 'failed to request crawl')
+        }
+      })
+    }
   }
 }

package/src/db/tables/moderation.ts

@@ -1,12 +1,5 @@
 import { Generated } from 'kysely'
-import {
-  REASONMISLEADING,
-  REASONOTHER,
-  REASONRUDE,
-  REASONSEXUAL,
-  REASONSPAM,
-  REASONVIOLATION,
-} from '../../lexicon/types/com/atproto/moderation/defs'
+import { com } from '../../lexicons/index.js'
 
 export const actionTableName = 'moderation_action'
 export const actionSubjectBlobTableName = 'moderation_action_subject_blob'
@@ -61,12 +54,12 @@ export interface ModerationReport {
   subjectUri: string | null
   subjectCid: string | null
   reasonType:
-    | typeof REASONSPAM
-    | typeof REASONOTHER
-    | typeof REASONMISLEADING
-    | typeof REASONRUDE
-    | typeof REASONSEXUAL
-    | typeof REASONVIOLATION
+    | com.atproto.moderation.defs.ReasonSpam
+    | com.atproto.moderation.defs.ReasonOther
+    | com.atproto.moderation.defs.ReasonMisleading
+    | com.atproto.moderation.defs.ReasonRude
+    | com.atproto.moderation.defs.ReasonSexual
+    | com.atproto.moderation.defs.ReasonViolation
   reason: string | null
   reportedByDid: string
   createdAt: string

package/src/disk-blobstore.ts

@@ -2,7 +2,6 @@ import fsSync from 'node:fs'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 import stream from 'node:stream'
-import { CID } from 'multiformats/cid'
 import {
   aggregateErrors,
   chunkArray,
@@ -11,6 +10,7 @@ import {
   rmIfExists,
 } from '@atproto/common'
 import { randomStr } from '@atproto/crypto'
+import { Cid } from '@atproto/lex-data'
 import { BlobNotFoundError, BlobStore } from '@atproto/repo'
 import { blobStoreLogger as log } from './logger'
 
@@ -56,11 +56,11 @@ export class DiskBlobStore implements BlobStore {
     return path.join(this.tmpLocation, this.did, key)
   }
 
-  getStoredPath(cid: CID): string {
+  getStoredPath(cid: Cid): string {
     return path.join(this.location, this.did, cid.toString())
   }
 
-  getQuarantinePath(cid: CID): string {
+  getQuarantinePath(cid: Cid): string {
     return path.join(this.quarantineLocation, this.did, cid.toString())
   }
 
@@ -68,7 +68,7 @@ export class DiskBlobStore implements BlobStore {
     return fileExists(this.getTmpPath(key))
   }
 
-  async hasStored(cid: CID): Promise<boolean> {
+  async hasStored(cid: Cid): Promise<boolean> {
     return fileExists(this.getStoredPath(cid))
   }
 
@@ -79,7 +79,7 @@ export class DiskBlobStore implements BlobStore {
     return key
   }
 
-  async makePermanent(key: string, cid: CID): Promise<void> {
+  async makePermanent(key: string, cid: Cid): Promise<void> {
     await this.ensureDir()
     const tmpPath = this.getTmpPath(key)
     const storedPath = this.getStoredPath(cid)
@@ -96,14 +96,14 @@ export class DiskBlobStore implements BlobStore {
   }
 
   async putPermanent(
-    cid: CID,
+    cid: Cid,
     bytes: Uint8Array | stream.Readable,
   ): Promise<void> {
     await this.ensureDir()
     await fs.writeFile(this.getStoredPath(cid), bytes)
   }
 
-  async quarantine(cid: CID): Promise<void> {
+  async quarantine(cid: Cid): Promise<void> {
     await this.ensureQuarantine()
     try {
       await fs.rename(this.getStoredPath(cid), this.getQuarantinePath(cid))
@@ -112,7 +112,7 @@ export class DiskBlobStore implements BlobStore {
     }
   }
 
-  async unquarantine(cid: CID): Promise<void> {
+  async unquarantine(cid: Cid): Promise<void> {
     await this.ensureDir()
     try {
       await fs.rename(this.getQuarantinePath(cid), this.getStoredPath(cid))
@@ -121,7 +121,7 @@ export class DiskBlobStore implements BlobStore {
     }
   }
 
-  async getBytes(cid: CID): Promise<Uint8Array> {
+  async getBytes(cid: Cid): Promise<Uint8Array> {
     try {
       return await fs.readFile(this.getStoredPath(cid))
     } catch (err) {
@@ -129,7 +129,7 @@ export class DiskBlobStore implements BlobStore {
     }
   }
 
-  async getStream(cid: CID): Promise<stream.Readable> {
+  async getStream(cid: Cid): Promise<stream.Readable> {
     const path = this.getStoredPath(cid)
     const exists = await fileExists(path)
     if (!exists) {
@@ -138,11 +138,11 @@ export class DiskBlobStore implements BlobStore {
     return fsSync.createReadStream(path)
   }
 
-  async delete(cid: CID): Promise<void> {
+  async delete(cid: Cid): Promise<void> {
     await rmIfExists(this.getStoredPath(cid))
   }
 
-  async deleteMany(cids: CID[]): Promise<void> {
+  async deleteMany(cids: Cid[]): Promise<void> {
     const errors: unknown[] = []
     for (const chunk of chunkArray(cids, 500)) {
       await Promise.all(

package/src/image/image-url-builder.ts

@@ -1,5 +1,5 @@
 import { BskyAppView } from '../bsky-app-view'
-import { ids } from '../lexicon/lexicons'
+import { com } from '../lexicons/index.js'
 
 export class ImageUrlBuilder {
   constructor(
@@ -10,7 +10,7 @@ export class ImageUrlBuilder {
   build(pattern: string, did: string, cid: string): string {
     return (
       this.bskyAppView?.getImageUrl(pattern, did, cid) ??
-      `https://${this.pdsHostname}/xrpc/${ids.ComAtprotoSyncGetBlob}?did=${did}&cid=${cid}`
+      `https://${this.pdsHostname}/xrpc/${com.atproto.sync.getBlob.$lxm}?did=${did}&cid=${cid}`
     )
   }
 }

package/src/index.ts

@@ -17,6 +17,7 @@ import {
   RedisRateLimiter,
   ResponseType,
   XRPCError,
+  createServer,
 } from '@atproto/xrpc-server'
 import apiRoutes from './api'
 import * as authRoutes from './auth-routes'
@@ -24,31 +25,32 @@ import * as basicRoutes from './basic-routes'
 import { ServerConfig, ServerSecrets } from './config'
 import { AppContext, AppContextOptions } from './context'
 import * as error from './error'
-import { createServer } from './lexicon'
-import * as AppBskyFeedGetFeedSkeleton from './lexicon/types/app/bsky/feed/getFeedSkeleton'
+import { app } from './lexicons.js'
 import { loggerMiddleware } from './logger'
 import { proxyHandler } from './pipethrough'
 import compression from './util/compression'
 import * as wellKnown from './well-known'
 
+export * from './lexicons.js'
 export { createSecretKeyObject } from './auth-verifier'
 export * from './config'
 export { AppContext } from './context'
 export { Database } from './db'
 export { DiskBlobStore } from './disk-blobstore'
-export { createServer as createLexiconServer } from './lexicon'
 export { httpLogger } from './logger'
 export { type CommitDataWithOps, type PreparedWrite } from './repo'
 export * as repoPrepare from './repo/prepare'
 export { scripts } from './scripts'
 export * as sequencer from './sequencer'
 
-// Legacy export for backwards compatibility
+/**
+ * @deprecated Legacy export for backwards compatibility
+ */
 export type SkeletonHandler = MethodHandler<
   void,
-  AppBskyFeedGetFeedSkeleton.QueryParams,
-  AppBskyFeedGetFeedSkeleton.HandlerInput,
-  AppBskyFeedGetFeedSkeleton.HandlerOutput
+  app.bsky.feed.getFeedSkeleton.$Params,
+  void,
+  app.bsky.feed.getFeedSkeleton.$Output
 >
 
 export class PDS {
@@ -73,8 +75,8 @@ export class PDS {
 
     const { rateLimits } = ctx.cfg
 
-    const server = createServer({
-      validateResponse: false,
+    const server = createServer([], {
+      validateResponse: cfg.service.devMode,
       payload: {
         jsonLimit: 150 * 1024, // 150kb
         textLimit: 100 * 1024, // 100kb
@@ -161,7 +163,7 @@ export class PDS {
     app.use(cors({ maxAge: DAY / SECOND }))
     app.use(basicRoutes.createRouter(ctx))
     app.use(wellKnown.createRouter(ctx))
-    app.use(server.xrpc.router)
+    app.use(server.router)
     app.use(error.handler)
 
     return new PDS({

package/src/lexicons.ts

@@ -0,0 +1,4 @@
+export * as com from './lexicons/com.js'
+export * as app from './lexicons/app.js'
+export * as chat from './lexicons/chat.js'
+export * as tools from './lexicons/tools.js'

package/src/pipethrough.ts

@@ -23,7 +23,7 @@ import {
 import { buildProxiedContentEncoding } from '@atproto-labs/xrpc-utils'
 import { isAccessPrivileged } from './auth-scope'
 import { AppContext } from './context'
-import { ids } from './lexicon/lexicons'
+import { chat, com, tools } from './lexicons/index.js'
 import { httpLogger } from './logger'
 
 export const proxyHandler = (ctx: AppContext): CatchallHandler => {
@@ -518,47 +518,47 @@ export function normalizeLxm(lxm: string) {
 }
 
 export const CHAT_BSKY_METHODS = new LxmSet([
-  ids.ChatBskyActorDeleteAccount,
-  ids.ChatBskyActorExportAccountData,
-  ids.ChatBskyConvoDeleteMessageForSelf,
-  ids.ChatBskyConvoGetConvo,
-  ids.ChatBskyConvoGetConvoForMembers,
-  ids.ChatBskyConvoGetLog,
-  ids.ChatBskyConvoGetMessages,
-  ids.ChatBskyConvoLeaveConvo,
-  ids.ChatBskyConvoListConvos,
-  ids.ChatBskyConvoMuteConvo,
-  ids.ChatBskyConvoSendMessage,
-  ids.ChatBskyConvoSendMessageBatch,
-  ids.ChatBskyConvoUnmuteConvo,
-  ids.ChatBskyConvoUpdateRead,
+  chat.bsky.actor.deleteAccount.$lxm,
+  chat.bsky.actor.exportAccountData.$lxm,
+  chat.bsky.convo.deleteMessageForSelf.$lxm,
+  chat.bsky.convo.getConvo.$lxm,
+  chat.bsky.convo.getConvoForMembers.$lxm,
+  chat.bsky.convo.getLog.$lxm,
+  chat.bsky.convo.getMessages.$lxm,
+  chat.bsky.convo.leaveConvo.$lxm,
+  chat.bsky.convo.listConvos.$lxm,
+  chat.bsky.convo.muteConvo.$lxm,
+  chat.bsky.convo.sendMessage.$lxm,
+  chat.bsky.convo.sendMessageBatch.$lxm,
+  chat.bsky.convo.unmuteConvo.$lxm,
+  chat.bsky.convo.updateRead.$lxm,
 ])
 
 export const PRIVILEGED_METHODS = new LxmSet([
   ...CHAT_BSKY_METHODS,
-  ids.ComAtprotoServerCreateAccount,
+  com.atproto.server.createAccount.$lxm,
 ])
 
 // These endpoints are related to account management and must be used directly,
 // not proxied or service-authed. Service auth may be utilized between PDS and
 // entryway for these methods.
 export const PROTECTED_METHODS = new LxmSet([
-  ids.ComAtprotoAdminSendEmail,
-  ids.ComAtprotoIdentityRequestPlcOperationSignature,
-  ids.ComAtprotoIdentitySignPlcOperation,
-  ids.ComAtprotoIdentityUpdateHandle,
-  ids.ComAtprotoServerActivateAccount,
-  ids.ComAtprotoServerConfirmEmail,
-  ids.ComAtprotoServerCreateAppPassword,
-  ids.ComAtprotoServerDeactivateAccount,
-  ids.ComAtprotoServerGetAccountInviteCodes,
-  ids.ComAtprotoServerGetSession,
-  ids.ComAtprotoServerListAppPasswords,
-  ids.ComAtprotoServerRequestAccountDelete,
-  ids.ComAtprotoServerRequestEmailConfirmation,
-  ids.ComAtprotoServerRequestEmailUpdate,
-  ids.ComAtprotoServerRevokeAppPassword,
-  ids.ComAtprotoServerUpdateEmail,
+  com.atproto.admin.sendEmail.$lxm,
+  com.atproto.identity.requestPlcOperationSignature.$lxm,
+  com.atproto.identity.signPlcOperation.$lxm,
+  com.atproto.identity.updateHandle.$lxm,
+  com.atproto.server.activateAccount.$lxm,
+  com.atproto.server.confirmEmail.$lxm,
+  com.atproto.server.createAppPassword.$lxm,
+  com.atproto.server.deactivateAccount.$lxm,
+  com.atproto.server.getAccountInviteCodes.$lxm,
+  com.atproto.server.getSession.$lxm,
+  com.atproto.server.listAppPasswords.$lxm,
+  com.atproto.server.requestAccountDelete.$lxm,
+  com.atproto.server.requestEmailConfirmation.$lxm,
+  com.atproto.server.requestEmailUpdate.$lxm,
+  com.atproto.server.revokeAppPassword.$lxm,
+  com.atproto.server.updateEmail.$lxm,
 ])
 
 const defaultService = (
@@ -569,38 +569,38 @@ const defaultService = (
   serviceInfo: { url: string; did: string } | null
 } => {
   switch (nsid) {
-    case ids.ToolsOzoneTeamAddMember:
-    case ids.ToolsOzoneTeamDeleteMember:
-    case ids.ToolsOzoneTeamUpdateMember:
-    case ids.ToolsOzoneTeamListMembers:
-    case ids.ToolsOzoneCommunicationCreateTemplate:
-    case ids.ToolsOzoneCommunicationDeleteTemplate:
-    case ids.ToolsOzoneCommunicationUpdateTemplate:
-    case ids.ToolsOzoneCommunicationListTemplates:
-    case ids.ToolsOzoneModerationEmitEvent:
-    case ids.ToolsOzoneModerationGetEvent:
-    case ids.ToolsOzoneModerationGetRecord:
-    case ids.ToolsOzoneModerationGetRepo:
-    case ids.ToolsOzoneModerationQueryEvents:
-    case ids.ToolsOzoneModerationQueryStatuses:
-    case ids.ToolsOzoneModerationSearchRepos:
-    case ids.ToolsOzoneModerationGetAccountTimeline:
-    case ids.ToolsOzoneVerificationListVerifications:
-    case ids.ToolsOzoneVerificationGrantVerifications:
-    case ids.ToolsOzoneVerificationRevokeVerifications:
-    case ids.ToolsOzoneSafelinkAddRule:
-    case ids.ToolsOzoneSafelinkUpdateRule:
-    case ids.ToolsOzoneSafelinkRemoveRule:
-    case ids.ToolsOzoneSafelinkQueryEvents:
-    case ids.ToolsOzoneSafelinkQueryRules:
-    case ids.ToolsOzoneModerationListScheduledActions:
-    case ids.ToolsOzoneModerationCancelScheduledActions:
-    case ids.ToolsOzoneModerationScheduleAction:
+    case tools.ozone.communication.createTemplate.$lxm:
+    case tools.ozone.communication.deleteTemplate.$lxm:
+    case tools.ozone.communication.listTemplates.$lxm:
+    case tools.ozone.communication.updateTemplate.$lxm:
+    case tools.ozone.moderation.cancelScheduledActions.$lxm:
+    case tools.ozone.moderation.emitEvent.$lxm:
+    case tools.ozone.moderation.getAccountTimeline.$lxm:
+    case tools.ozone.moderation.getEvent.$lxm:
+    case tools.ozone.moderation.getRecord.$lxm:
+    case tools.ozone.moderation.getRepo.$lxm:
+    case tools.ozone.moderation.listScheduledActions.$lxm:
+    case tools.ozone.moderation.queryEvents.$lxm:
+    case tools.ozone.moderation.queryStatuses.$lxm:
+    case tools.ozone.moderation.scheduleAction.$lxm:
+    case tools.ozone.moderation.searchRepos.$lxm:
+    case tools.ozone.safelink.addRule.$lxm:
+    case tools.ozone.safelink.queryEvents.$lxm:
+    case tools.ozone.safelink.queryRules.$lxm:
+    case tools.ozone.safelink.removeRule.$lxm:
+    case tools.ozone.safelink.updateRule.$lxm:
+    case tools.ozone.team.addMember.$lxm:
+    case tools.ozone.team.deleteMember.$lxm:
+    case tools.ozone.team.listMembers.$lxm:
+    case tools.ozone.team.updateMember.$lxm:
+    case tools.ozone.verification.grantVerifications.$lxm:
+    case tools.ozone.verification.listVerifications.$lxm:
+    case tools.ozone.verification.revokeVerifications.$lxm:
       return {
         serviceId: 'atproto_labeler',
         serviceInfo: ctx.cfg.modService,
       }
-    case ids.ComAtprotoModerationCreateReport:
+    case com.atproto.moderation.createReport.$lxm:
       return {
         serviceId: 'atproto_labeler',
         serviceInfo: ctx.cfg.reportService,

package/src/read-after-write/types.ts

@@ -1,25 +1,23 @@
-import { CID } from 'multiformats/cid'
-import { AtUri } from '@atproto/syntax'
-import { Headers } from '@atproto/xrpc'
-import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
-import { Record as PostRecord } from '../lexicon/types/app/bsky/feed/post'
+import { Cid } from '@atproto/lex-data'
+import { AtUri, DatetimeString } from '@atproto/syntax'
+import { app } from '../lexicons/index.js'
 import { LocalViewer } from './viewer'
 
 export type LocalRecords = {
   count: number
-  profile: RecordDescript<ProfileRecord> | null
-  posts: RecordDescript<PostRecord>[]
+  profile: RecordDescript<app.bsky.actor.profile.Main> | null
+  posts: RecordDescript<app.bsky.feed.post.Main>[]
 }
 
 export type RecordDescript<T> = {
   uri: AtUri
-  cid: CID
-  indexedAt: string
+  cid: Cid
+  indexedAt: DatetimeString
   record: T
 }
 
 export type ApiRes<T> = {
-  headers: Headers
+  headers: Record<string, string | undefined>
   data: T
 }