@atproto/bsky 0.0.147 → 0.0.149

package/src/config.ts

@@ -1,4 +1,10 @@
 import assert from 'node:assert'
+import { subLogger as log } from './logger'
+
+type LiveNowConfig = {
+  did: string
+  domains: string[]
+}[]
 
 export interface ServerConfigValues {
   // service
@@ -9,6 +15,7 @@ export interface ServerConfigValues {
   serverDid: string
   alternateAudienceDids: string[]
   entrywayJwtPublicKeyHex?: string
+  liveNowConfig?: LiveNowConfig
   // external services
   etcdHosts: string[]
   dataplaneUrls: string[]
@@ -81,6 +88,19 @@ export class ServerConfig {
     const alternateAudienceDids = envList(process.env.BSKY_ALT_AUDIENCE_DIDS)
     const entrywayJwtPublicKeyHex =
       process.env.BSKY_ENTRYWAY_JWT_PUBLIC_KEY_HEX || undefined
+    let liveNowConfig: LiveNowConfig | undefined
+    if (process.env.BSKY_LIVE_NOW_CONFIG) {
+      try {
+        const parsed = JSON.parse(process.env.BSKY_LIVE_NOW_CONFIG)
+        if (isLiveNowConfig(parsed)) {
+          liveNowConfig = parsed
+        } else {
+          throw new Error('Live Now config failed format validation')
+        }
+      } catch (err) {
+        log.error({ err }, 'Invalid BSKY_LIVE_NOW_CONFIG')
+      }
+    }
     const handleResolveNameservers = envList(
       process.env.BSKY_HANDLE_RESOLVE_NAMESERVERS,
     )
@@ -200,6 +220,7 @@ export class ServerConfig {
       serverDid,
       alternateAudienceDids,
       entrywayJwtPublicKeyHex,
+      liveNowConfig,
       etcdHosts,
       dataplaneUrls,
       dataplaneUrlsEtcdKeyPrefix,
@@ -285,6 +306,10 @@ export class ServerConfig {
     return this.cfg.entrywayJwtPublicKeyHex
   }
 
+  get liveNowConfig() {
+    return this.cfg.liveNowConfig
+  }
+
   get etcdHosts() {
     return this.cfg.etcdHosts
   }
@@ -482,3 +507,17 @@ function envList(str: string | undefined): string[] {
   if (str === undefined || str.length === 0) return []
   return str.split(',')
 }
+
+function isLiveNowConfig(data: any): data is LiveNowConfig {
+  return (
+    Array.isArray(data) &&
+    data.every(
+      (item) =>
+        typeof item === 'object' &&
+        item !== null &&
+        typeof item.did === 'string' &&
+        Array.isArray(item.domains) &&
+        item.domains.every((domain: any) => typeof domain === 'string'),
+    )
+  )
+}

package/src/data-plane/server/background.ts

@@ -16,7 +16,7 @@ export class BackgroundQueue {
     this.queue
       .add(() => task(this.db))
       .catch((err) => {
-        dbLogger.error(err, 'background queue task failed')
+        dbLogger.error({ err }, 'background queue task failed')
       })
   }
 

package/src/data-plane/server/indexing/index.ts

@@ -31,6 +31,7 @@ import * as Postgate from './plugins/post-gate'
 import * as Profile from './plugins/profile'
 import * as Repost from './plugins/repost'
 import * as StarterPack from './plugins/starter-pack'
+import * as Status from './plugins/status'
 import * as Threadgate from './plugins/thread-gate'
 import * as Verification from './plugins/verification'
 import { RecordProcessor } from './processor'
@@ -53,6 +54,7 @@ export class IndexingService {
     labeler: Labeler.PluginType
     chatDeclaration: ChatDeclaration.PluginType
     verification: Verification.PluginType
+    status: Status.PluginType
   }
 
   constructor(
@@ -77,6 +79,7 @@ export class IndexingService {
       labeler: Labeler.makePlugin(this.db, this.background),
       chatDeclaration: ChatDeclaration.makePlugin(this.db, this.background),
       verification: Verification.makePlugin(this.db, this.background),
+      status: Status.makePlugin(this.db, this.background),
     }
   }
 

package/src/data-plane/server/indexing/plugins/status.ts

@@ -0,0 +1,61 @@
+import { CID } from 'multiformats/cid'
+import { AtUri } from '@atproto/syntax'
+import * as lex from '../../../../lexicon/lexicons'
+import { BackgroundQueue } from '../../background'
+import { Database } from '../../db'
+import { DatabaseSchema } from '../../db/database-schema'
+import { RecordProcessor } from '../processor'
+
+// @NOTE this indexer is a placeholder to ensure it gets indexed in the generic records table
+
+const lexId = lex.ids.AppBskyActorStatus
+
+const insertFn = async (
+  _db: DatabaseSchema,
+  uri: AtUri,
+  _cid: CID,
+  _obj: unknown,
+  _timestamp: string,
+): Promise<unknown | null> => {
+  if (uri.rkey !== 'self') return null
+  return true
+}
+
+const findDuplicate = async (): Promise<AtUri | null> => {
+  return null
+}
+
+const notifsForInsert = () => {
+  return []
+}
+
+const deleteFn = async (
+  _db: DatabaseSchema,
+  uri: AtUri,
+): Promise<unknown | null> => {
+  if (uri.rkey !== 'self') return null
+  return true
+}
+
+const notifsForDelete = () => {
+  return { notifs: [], toDelete: [] }
+}
+
+export type PluginType = RecordProcessor<unknown, unknown>
+
+export const makePlugin = (
+  db: Database,
+  background: BackgroundQueue,
+): PluginType => {
+  const processor = new RecordProcessor(db, background, {
+    lexId,
+    insertFn,
+    findDuplicate,
+    deleteFn,
+    notifsForInsert,
+    notifsForDelete,
+  })
+  return processor
+}
+
+export default makePlugin

package/src/data-plane/server/routes/index.ts

@@ -14,7 +14,6 @@ import lists from './lists'
 import moderation from './moderation'
 import mutes from './mutes'
 import notifs from './notifs'
-import posts from './posts'
 import profile from './profile'
 import quotes from './quotes'
 import records from './records'
@@ -41,7 +40,6 @@ export default (db: Database, idResolver: IdResolver) =>
       ...moderation(db),
       ...mutes(db),
       ...notifs(db),
-      ...posts(db),
       ...profile(db),
       ...quotes(db),
       ...records(db),

package/src/data-plane/server/routes/profile.ts

@@ -25,37 +25,46 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
     const profileUris = dids.map(
       (did) => `at://${did}/app.bsky.actor.profile/self`,
     )
+    const statusUris = dids.map(
+      (did) => `at://${did}/app.bsky.actor.status/self`,
+    )
     const chatDeclarationUris = dids.map(
       (did) => `at://${did}/chat.bsky.actor.declaration/self`,
     )
     const { ref } = db.db.dynamic
-    const [handlesRes, verificationsReceived, profiles, chatDeclarations] =
-      await Promise.all([
-        db.db
-          .selectFrom('actor')
-          .leftJoin('actor_state', 'actor_state.did', 'actor.did')
-          .where('actor.did', 'in', dids)
-          .selectAll('actor')
-          .select('actor_state.priorityNotifs')
-          .select([
-            db.db
-              .selectFrom('labeler')
-              .whereRef('creator', '=', ref('actor.did'))
-              .select(sql<true>`${true}`.as('val'))
-              .as('isLabeler'),
-          ])
-          .execute(),
-        db.db
-          .selectFrom('verification')
-          .selectAll('verification')
-          .innerJoin('actor', 'actor.did', 'verification.creator')
-          .where('verification.subject', 'in', dids)
-          .where('actor.trustedVerifier', '=', true)
-          .orderBy('sortedAt', 'asc')
-          .execute(),
-        getRecords(db)({ uris: profileUris }),
-        getRecords(db)({ uris: chatDeclarationUris }),
-      ])
+    const [
+      handlesRes,
+      verificationsReceived,
+      profiles,
+      statuses,
+      chatDeclarations,
+    ] = await Promise.all([
+      db.db
+        .selectFrom('actor')
+        .leftJoin('actor_state', 'actor_state.did', 'actor.did')
+        .where('actor.did', 'in', dids)
+        .selectAll('actor')
+        .select('actor_state.priorityNotifs')
+        .select([
+          db.db
+            .selectFrom('labeler')
+            .whereRef('creator', '=', ref('actor.did'))
+            .select(sql<true>`${true}`.as('val'))
+            .as('isLabeler'),
+        ])
+        .execute(),
+      db.db
+        .selectFrom('verification')
+        .selectAll('verification')
+        .innerJoin('actor', 'actor.did', 'verification.creator')
+        .where('verification.subject', 'in', dids)
+        .where('actor.trustedVerifier', '=', true)
+        .orderBy('sortedAt', 'asc')
+        .execute(),
+      getRecords(db)({ uris: profileUris }),
+      getRecords(db)({ uris: statusUris }),
+      getRecords(db)({ uris: chatDeclarationUris }),
+    ])
 
     const verificationsBySubjectDid = verificationsReceived.reduce(
       (acc, cur) => {
@@ -70,6 +79,9 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
     const byDid = keyBy(handlesRes, 'did')
     const actors = dids.map((did, i) => {
       const row = byDid.get(did)
+
+      const status = statuses.records[i]
+
       const chatDeclaration = parseRecordBytes(
         chatDeclarations.records[i].record,
       )
@@ -102,11 +114,15 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
         priorityNotifications: row?.priorityNotifs ?? false,
         trustedVerifier: row?.trustedVerifier ?? false,
         verifiedBy,
+        statusRecord: status,
+        tags: [],
+        profileTags: [],
       }
     })
     return { actors }
   },
 
+  // @TODO handle req.lookupUnidirectional w/ networked handle resolution
   async getDidsByHandles(req) {
     const { handles } = req
     if (handles.length === 0) {

package/src/data-plane/server/routes/records.ts

@@ -25,6 +25,7 @@ export default (db: Database): Partial<ServiceImpl<typeof Service>> => ({
   getActorChatDeclarationRecords: getRecords(db, ids.ChatBskyActorDeclaration),
   getStarterPackRecords: getRecords(db, ids.AppBskyGraphStarterpack),
   getVerificationRecords: getRecords(db, ids.AppBskyGraphVerification),
+  getStatusRecords: getRecords(db, ids.AppBskyActorStatus),
 })
 
 export const getRecords =

package/src/error.ts

@@ -3,7 +3,7 @@ import { XRPCError } from '@atproto/xrpc-server'
 import { httpLogger as log } from './logger'
 
 export const handler: ErrorRequestHandler = (err, _req, res, next) => {
-  log.error(err, 'unexpected internal server error')
+  log.error({ err }, 'unexpected internal server error')
   if (res.headersSent) {
     return next(err)
   }

package/src/hydration/actor.ts

@@ -1,6 +1,7 @@
 import { mapDefined } from '@atproto/common'
 import { DataPlaneClient } from '../data-plane/client'
 import { Record as ProfileRecord } from '../lexicon/types/app/bsky/actor/profile'
+import { Record as StatusRecord } from '../lexicon/types/app/bsky/actor/status'
 import { Record as ChatDeclarationRecord } from '../lexicon/types/chat/bsky/actor/declaration'
 import { VerificationMeta } from '../proto/bsky_pb'
 import {
@@ -27,6 +28,7 @@ export type Actor = {
   priorityNotifications: boolean
   trustedVerifier?: boolean
   verifications: VerificationHydrationState[]
+  status?: RecordInfo<StatusRecord>
 }
 
 export type VerificationHydrationState = {
@@ -45,6 +47,9 @@ export type ChatDeclaration = RecordInfo<ChatDeclarationRecord>
 
 export type ChatDeclarations = HydrationMap<ChatDeclaration>
 
+export type Status = RecordInfo<StatusRecord>
+export type Statuses = HydrationMap<Status>
+
 export type ProfileViewerState = {
   muted?: boolean
   mutedByList?: string
@@ -88,10 +93,16 @@ export class ActorHydrator {
     }
   }
 
-  async getDids(handleOrDids: string[]): Promise<(string | undefined)[]> {
+  async getDids(
+    handleOrDids: string[],
+    opts?: { lookupUnidirectional?: boolean },
+  ): Promise<(string | undefined)[]> {
     const handles = handleOrDids.filter((actor) => !actor.startsWith('did:'))
     const res = handles.length
-      ? await this.dataplane.getDidsByHandles({ handles })
+      ? await this.dataplane.getDidsByHandles({
+          handles,
+          lookupUnidirectional: opts?.lookupUnidirectional,
+        })
       : { dids: [] }
     const didByHandle = handles.reduce(
       (acc, cur, i) => {
@@ -141,6 +152,10 @@ export class ActorHydrator {
         ? parseRecord<ProfileRecord>(actor.profile, includeTakedowns)
         : undefined
 
+      const status = actor.statusRecord
+        ? parseRecord<StatusRecord>(actor.statusRecord, includeTakedowns)
+        : undefined
+
       const verifications = mapDefined(
         Object.entries(actor.verifiedBy),
         ([actorDid, verificationMeta]) => {
@@ -178,6 +193,7 @@ export class ActorHydrator {
         priorityNotifications: actor.priorityNotifications,
         trustedVerifier: actor.trustedVerifier,
         verifications,
+        status: status,
       })
     }, new HydrationMap<Actor>())
   }
@@ -197,6 +213,15 @@ export class ActorHydrator {
     }, new HydrationMap<ChatDeclaration>())
   }
 
+  async getStatus(uris: string[], includeTakedowns = false): Promise<Statuses> {
+    if (!uris.length) return new HydrationMap<Status>()
+    const res = await this.dataplane.getStatusRecords({ uris })
+    return uris.reduce((acc, uri, i) => {
+      const record = parseRecord<StatusRecord>(res.records[i], includeTakedowns)
+      return acc.set(uri, record ?? null)
+    }, new HydrationMap<Status>())
+  }
+
   // "naive" because this method does not verify the existence of the list itself
   // a later check in the main hydrator will remove list uris that have been deleted or
   // repurposed to "curate lists"

package/src/hydration/feed.ts

@@ -206,9 +206,15 @@ export class FeedHydrator {
     }, new HydrationMap<ThreadContext>())
   }
 
-  async getPostAggregates(refs: ItemRef[]): Promise<PostAggs> {
+  async getPostAggregates(
+    refs: ItemRef[],
+    viewer: string | null,
+  ): Promise<PostAggs> {
     if (!refs.length) return new HydrationMap<PostAgg>()
-    const counts = await this.dataplane.getInteractionCounts({ refs })
+    const counts = await this.dataplane.getInteractionCounts({
+      refs,
+      skipCacheForDids: viewer ? [viewer] : undefined,
+    })
     return refs.reduce((acc, { uri }, i) => {
       return acc.set(uri, {
         likes: counts.likes[i] ?? 0,
@@ -250,9 +256,15 @@ export class FeedHydrator {
     }, new HydrationMap<FeedGenViewerState>())
   }
 
-  async getFeedGenAggregates(refs: ItemRef[]): Promise<FeedGenAggs> {
+  async getFeedGenAggregates(
+    refs: ItemRef[],
+    viewer: string | null,
+  ): Promise<FeedGenAggs> {
     if (!refs.length) return new HydrationMap<FeedGenAgg>()
-    const counts = await this.dataplane.getInteractionCounts({ refs })
+    const counts = await this.dataplane.getInteractionCounts({
+      refs,
+      skipCacheForDids: viewer ? [viewer] : undefined,
+    })
     return refs.reduce((acc, { uri }, i) => {
       return acc.set(uri, {
         likes: counts.likes[i] ?? 0,

package/src/hydration/hydrator.ts

@@ -37,6 +37,7 @@ import {
   Threadgates,
 } from './feed'
 import {
+  BlockEntry,
   Follows,
   GraphHydrator,
   ListAggs,
@@ -265,7 +266,7 @@ export class Hydrator {
     const [state, profileAggs, bidirectionalBlocks] = await Promise.all([
       this.hydrateProfiles(allDids, ctx),
       this.actor.getProfileAggregates(dids),
-      this.hydrateBidirectionalBlocks(subjectsToKnownFollowersMap),
+      this.hydrateBidirectionalBlocks(subjectsToKnownFollowersMap, ctx),
     ])
     const starterPackUriSet = new Set<string>()
     state.actors?.forEach((actor) => {
@@ -486,12 +487,12 @@ export class Hydrator {
       starterPackState,
       postgates,
     ] = await Promise.all([
-      this.feed.getPostAggregates(allRefs),
+      this.feed.getPostAggregates(allRefs, ctx.viewer),
       ctx.viewer
         ? this.feed.getPostViewerStates(threadRefs, ctx.viewer)
         : undefined,
       this.label.getLabelsForSubjects(allPostUris, ctx.labelers),
-      this.hydratePostBlocks(posts),
+      this.hydratePostBlocks(posts, ctx),
       this.hydrateProfiles(allPostUris.map(didFromUri), ctx),
       this.hydrateLists([...nestedListUris, ...threadgateListUris], ctx),
       this.hydrateFeedGens(nestedFeedGenUris, ctx),
@@ -522,7 +523,10 @@ export class Hydrator {
     )
   }
 
-  private async hydratePostBlocks(posts: Posts): Promise<PostBlocks> {
+  private async hydratePostBlocks(
+    posts: Posts,
+    ctx: HydrateCtx,
+  ): Promise<PostBlocks> {
     const postBlocks = new HydrationMap<PostBlock>()
     const postBlocksPairs = new Map<string, PostBlockPairs>()
     const relationships: RelationshipPair[] = []
@@ -557,6 +561,7 @@ export class Hydrator {
     // replace embed/parent/root pairs with block state
     const blocks = await this.hydrateBidirectionalBlocks(
       pairsToMap(relationships),
+      ctx,
     )
     for (const [uri, { embed, parent, root }] of postBlocksPairs) {
       postBlocks.set(uri, {
@@ -683,7 +688,10 @@ export class Hydrator {
     const [feedgens, feedgenAggs, feedgenViewers, profileState, labels] =
       await Promise.all([
         this.feed.getFeedGens(uris, ctx.includeTakedowns),
-        this.feed.getFeedGenAggregates(uris.map((uri) => ({ uri }))),
+        this.feed.getFeedGenAggregates(
+          uris.map((uri) => ({ uri })),
+          ctx.viewer,
+        ),
         ctx.viewer
           ? this.feed.getFeedGenViewerStates(uris, ctx.viewer)
           : undefined,
@@ -782,6 +790,7 @@ export class Hydrator {
     )
     const blocks = await this.hydrateBidirectionalBlocks(
       pairsToMap(listCreatorMemberPairs),
+      ctx,
     )
     // sample top list items per starter pack based on their follows
     const listMemberAggs = await this.actor.getProfileAggregates(listMemberDids)
@@ -839,7 +848,7 @@ export class Hydrator {
         pairs.push([authorDid, didFromUri(uri)])
       }
     }
-    const blocks = await this.hydrateBidirectionalBlocks(pairsToMap(pairs))
+    const blocks = await this.hydrateBidirectionalBlocks(pairsToMap(pairs), ctx)
     const likeBlocks = new HydrationMap<LikeBlock>()
     for (const [uri, like] of likes) {
       if (like) {
@@ -925,7 +934,10 @@ export class Hydrator {
   }
 
   // provides partial hydration state within getFollows / getFollowers, mainly for applying rules
-  async hydrateFollows(uris: string[]): Promise<HydrationState> {
+  async hydrateFollows(
+    uris: string[],
+    ctx: HydrateCtx,
+  ): Promise<HydrationState> {
     const follows = await this.graph.getFollows(uris)
     const pairs: RelationshipPair[] = []
     for (const [uri, follow] of follows) {
@@ -933,7 +945,7 @@ export class Hydrator {
         pairs.push([didFromUri(uri), follow.record.subject])
       }
     }
-    const blocks = await this.hydrateBidirectionalBlocks(pairsToMap(pairs))
+    const blocks = await this.hydrateBidirectionalBlocks(pairsToMap(pairs), ctx)
     const followBlocks = new HydrationMap<FollowBlock>()
     for (const [uri, follow] of follows) {
       if (follow) {
@@ -950,6 +962,7 @@ export class Hydrator {
 
   async hydrateBidirectionalBlocks(
     didMap: Map<string, string[]>, // DID -> DID[]
+    ctx: HydrateCtx,
   ): Promise<BidirectionalBlocks> {
     const pairs: RelationshipPair[] = []
     for (const [source, targets] of didMap) {
@@ -958,32 +971,56 @@ export class Hydrator {
       }
     }
 
-    const result = new HydrationMap<HydrationMap<boolean>>()
     const blocks = await this.graph.getBidirectionalBlocks(pairs)
-
-    // lookup list authors to apply takedown status to blocklists
-    const listAuthorDids = new Set<string>()
+    const listUrisSet = new Set<string>()
     for (const [source, targets] of didMap) {
       for (const target of targets) {
         const block = blocks.get(source, target)
         if (block?.blockListUri) {
-          listAuthorDids.add(uriToDid(block.blockListUri))
+          listUrisSet.add(block.blockListUri)
         }
       }
     }
+    const listUris = [...listUrisSet]
 
-    const activeListAuthors = await this.actor.getActors([...listAuthorDids])
+    // if a list no longer exists or is not a mod list, then remove from block entry
+    const listState = await this.hydrateListsBasic(listUris, ctx)
+    for (const [source, targets] of didMap) {
+      for (const target of targets) {
+        const block = blocks.get(source, target)
+        if (!isModList(block?.blockListUri, listState)) {
+          delete block?.blockListUri
+        }
+      }
+    }
 
+    const result: BidirectionalBlocks = new HydrationMap<
+      HydrationMap<boolean>
+    >()
     for (const [source, targets] of didMap) {
       const didBlocks = new HydrationMap<boolean>()
       for (const target of targets) {
         const block = blocks.get(source, target)
-        const isBlocked = !!(
-          block?.blockUri ||
-          (block?.blockListUri &&
-            activeListAuthors.get(uriToDid(block.blockListUri)))
+
+        // If a list no longer exists or is not a mod list, then remove from block entry.
+        // isModList confirms the list exists in listState, which ensures it wasn't taken down.
+        if (!isModList(block?.blockListUri, listState)) {
+          delete block?.blockListUri
+        }
+
+        const blockEntry: BlockEntry = {
+          blockUri: block?.blockUri,
+          blockListUri:
+            block?.blockListUri &&
+            listState.actors?.get(uriToDid(block.blockListUri))
+              ? block.blockListUri
+              : undefined,
+        }
+
+        didBlocks.set(
+          target,
+          !!blockEntry.blockUri || !!blockEntry.blockListUri,
         )
-        didBlocks.set(target, isBlocked)
       }
       result.set(source, didBlocks)
     }
@@ -1002,7 +1039,7 @@ export class Hydrator {
     const [labelers, labelerAggs, labelerViewers, profileState] =
       await Promise.all([
         this.label.getLabelers(dids, ctx.includeTakedowns),
-        this.label.getLabelerAggregates(dids),
+        this.label.getLabelerAggregates(dids, ctx.viewer),
         ctx.viewer
           ? this.label.getLabelerViewerStates(dids, ctx.viewer)
           : undefined,
@@ -1093,6 +1130,12 @@ export class Hydrator {
           uri,
         ) ?? undefined
       )
+    } else if (collection === ids.AppBskyActorStatus) {
+      if (parsed.rkey !== 'self') return
+      return (
+        (await this.actor.getStatus([uri], includeTakedowns)).get(uri) ??
+        undefined
+      )
     } else if (collection === ids.AppBskyActorProfile) {
       const did = parsed.hostname
       const actor = (
@@ -1251,7 +1294,7 @@ const getListUrisFromThreadgates = (gates: Threadgates) => {
 }
 
 const isBlocked = (blocks: BidirectionalBlocks, [a, b]: RelationshipPair) => {
-  return blocks.get(a)?.get(b) ?? null
+  return blocks.get(a)?.get(b) ?? false
 }
 
 const pairsToMap = (pairs: RelationshipPair[]): Map<string, string[]> => {

package/src/hydration/label.ts

@@ -156,9 +156,15 @@ export class LabelHydrator {
     }, new HydrationMap<LabelerViewerState>())
   }
 
-  async getLabelerAggregates(dids: string[]): Promise<LabelerAggs> {
+  async getLabelerAggregates(
+    dids: string[],
+    viewer: string | null,
+  ): Promise<LabelerAggs> {
     const refs = dids.map((did) => ({ uri: labelerDidToUri(did) }))
-    const counts = await this.dataplane.getInteractionCounts({ refs })
+    const counts = await this.dataplane.getInteractionCounts({
+      refs,
+      skipCacheForDids: viewer ? [viewer] : undefined,
+    })
     return dids.reduce((acc, did, i) => {
       return acc.set(did, {
         likes: counts.likes[i] ?? 0,

package/src/image/server.ts

@@ -102,7 +102,7 @@ export function createMiddleware(
         // Cache in the background
         cache
           .put(cacheKey, cloneStream(processor))
-          .catch((err) => log.error(err, 'failed to cache image'))
+          .catch((err) => log.error({ err }, 'failed to cache image'))
 
         res.statusCode = 200
         res.setHeader('cache-control', `public, max-age=31536000`) // 1 year