@takosjp/yurucommu-core 3.3.0 → 3.4.1

package/src/backend/routes/activitypub/handlers/inbox-content-handlers.ts

@@ -1,5 +1,15 @@
 import type { Database } from "../../../../db/index.ts";
-import { and, count, eq, gt, inArray, isNotNull, or, sql } from "drizzle-orm";
+import {
+  and,
+  count,
+  eq,
+  gt,
+  inArray,
+  isNotNull,
+  isNull,
+  or,
+  sql,
+} from "drizzle-orm";
 import type { BatchItem } from "drizzle-orm/batch";
 import {
   activities,
@@ -8,6 +18,7 @@ import {
   announces,
   blocks,
   bookmarks,
+  communities,
   follows,
   inbox as inboxTable,
   likes,
@@ -45,6 +56,8 @@ import {
   fetchAndUpsertActorCache,
   getInstanceFetchSignerByDb,
 } from "../../../lib/activitypub-actor-cache.ts";
+import { fetchWithTimeout } from "../../../lib/federation-fetch.ts";
+import { signRequest } from "../../../lib/ap-signing.ts";
 import { enqueueDeliveryToActor } from "../../../lib/delivery/queue.ts";
 import { destinationDeclaresAlias } from "../../../lib/account-migration.ts";
 import { chunkForInClause } from "../../../lib/chunk.ts";
@@ -132,13 +145,13 @@ function isActorTypeUpdate(type: string | string[] | undefined): boolean {
 
 // The ActivityStreams public-collection magic value, including the legacy
 // short forms some implementations still emit.
-const PUBLIC_COLLECTION = new Set([
+export const PUBLIC_COLLECTION = new Set([
   "https://www.w3.org/ns/activitystreams#Public",
   "as:Public",
   "Public",
 ]);
 
-function addressesPublic(addresses: string[]): boolean {
+export function addressesPublic(addresses: string[]): boolean {
   return addresses.some((a) => PUBLIC_COLLECTION.has(a));
 }
 
@@ -146,7 +159,7 @@ function addressesPublic(addresses: string[]): boolean {
 // and NOT to Public is a followers-only post. We match any `/followers`
 // collection by suffix (mirrors isDirectNote), which covers the author's
 // collection without needing to resolve it.
-function addressesFollowers(addresses: string[]): boolean {
+export function addressesFollowers(addresses: string[]): boolean {
   return addresses.some((a) => a.endsWith("/followers"));
 }
 
@@ -194,7 +207,7 @@ function isDirectShapedNote(object: { to?: string[]; cc?: string[] }): boolean {
 // Cap persisted addressing arrays so a remote cannot bloat a row with a huge
 // to/cc list; 64 entries is far beyond any real audience and keeps the explicit-
 // recipient (mention) gate working.
-const MAX_ADDRESS_ENTRIES = 64;
+export const MAX_ADDRESS_ENTRIES = 64;
 function boundAddressJson(addresses: string[] | undefined): string {
   if (!Array.isArray(addresses) || addresses.length === 0) return "[]";
   return JSON.stringify(
@@ -204,6 +217,21 @@ function boundAddressJson(addresses: string[] | undefined): string {
   );
 }
 
+/**
+ * Normalize an AS2 addressing field (`to` / `cc` / `audience`) to a bounded list
+ * of strings. The field may be absent, a bare string, or an array mixing
+ * strings and embedded objects; only the string forms are usable as a
+ * collection id, and the same 64-entry cap applies so a remote cannot force a
+ * huge `IN (...)` lookup.
+ */
+function addressList(value: unknown): string[] {
+  if (typeof value === "string") return [value];
+  if (!Array.isArray(value)) return [];
+  return value
+    .filter((a): a is string => typeof a === "string")
+    .slice(0, MAX_ADDRESS_ENTRIES);
+}
+
 /**
  * Reject an inbound object whose `object.id` is asserted under a host the
  * delivering actor does not control (object-ID squatting / cross-origin
@@ -888,6 +916,35 @@ export async function handleCreateStory(
     storyDataJson = JSON.stringify({ ...attachmentData, overlays: undefined });
   }
 
+  // Carry the community scope across the federation boundary. A story that
+  // arrived through community fanout is addressed to the community's followers
+  // collection, not the author's; storing it with no scope made the local read
+  // gate treat it as a personal story and serve it to every local follower of
+  // the author, member or not. Resolve the addressed collection against the
+  // communities this instance actually knows and only then mark the scope —
+  // an unresolvable audience is left unscoped rather than trusted, and the
+  // membership gate is still evaluated locally against `community_members`.
+  const addressedCollections = [
+    ...addressList((activity as { audience?: unknown }).audience),
+    ...addressList(object.to),
+    ...addressList((object as { audience?: unknown }).audience),
+  ];
+  const community = addressedCollections.length
+    ? await db
+        .select({ apId: communities.apId })
+        .from(communities)
+        .where(
+          and(
+            or(
+              inArray(communities.followersUrl, addressedCollections),
+              inArray(communities.apId, addressedCollections),
+            ),
+            isNull(communities.deletedAt),
+          ),
+        )
+        .get()
+    : undefined;
+
   const inserted = await db
     .insert(objects)
     .values({
@@ -896,6 +953,12 @@ export async function handleCreateStory(
       attributedTo: actor,
       content: "",
       attachmentsJson: storyDataJson,
+      ...(community
+        ? {
+            communityApId: community.apId,
+            audienceJson: JSON.stringify([community.apId]),
+          }
+        : {}),
       endTime,
       published: publishedAt,
       isLocal: 0,
@@ -907,6 +970,142 @@ export async function handleCreateStory(
   if (!inserted) return; // duplicate
 }
 
+// ---------------------------------------------------------------------------
+// Announce target resolution (fetch-and-store a boosted remote Note)
+// ---------------------------------------------------------------------------
+
+// Upper bound on the fetch of a boosted remote object. Mirrors the actor-cache
+// fetch timeout; the body size is already capped by fetchWithTimeout's wrapper.
+const ANNOUNCED_OBJECT_FETCH_TIMEOUT_MS = 15_000;
+
+/**
+ * Resolve an inbound Announce whose target this instance has never seen: fetch
+ * the boosted object from its origin, validate it, and persist it as a remote
+ * Note so the announce edge recorded by handleAnnounce surfaces in feeds
+ * ("reposted by X") instead of dangling on an unknown ap_id.
+ *
+ * Reuses the SSRF-guarded federation fetch discipline end to end:
+ * `fetchWithTimeout` (resolver-pinned DNS validation, no redirects, capped +
+ * time-bounded body) with the GET signed as the instance actor so a
+ * secure-mode remote serves the document (mirrors fetchAndUpsertActorCache).
+ *
+ * Validation mirrors the inbound Create(Note) gates:
+ *   - the document's `id` must equal the fetched URL (no id squatting);
+ *   - `attributedTo` must be same-origin with the object id (a remote author
+ *     may only own objects under its own host — mirrors
+ *     isObjectIdOriginMismatch, and a local-origin object is never fetched);
+ *   - type must include "Note"; direct/DM-shaped addressing is refused;
+ *   - only world-readable classifications (public / unlisted) are persisted —
+ *     a boost must never widen a followers-only/direct object's audience, and
+ *     this instance cannot verify a remote author's follower audience.
+ *
+ * Depth cap: the object's `inReplyTo` is stored verbatim but NEVER resolved —
+ * a single Announce triggers at most one object fetch (plus a best-effort
+ * author-profile cache fill), not a thread walk.
+ *
+ * Best-effort by contract: every failure returns false and the Announce is
+ * dropped exactly as it was before this path existed.
+ */
+export async function fetchAndPersistAnnouncedNote(
+  db: Database,
+  objectId: string,
+  baseUrl: string,
+): Promise<boolean> {
+  // Never fetch a local id (a local object that does not exist is just gone)
+  // and never fetch an unsafe URL (non-http(s), credentials, blocked host…).
+  if (isLocal(objectId, baseUrl) || !isSafeRemoteUrl(objectId)) return false;
+
+  let note: ActivityObject & { attributedTo?: unknown };
+  try {
+    const headers: Record<string, string> = {
+      Accept: "application/activity+json, application/ld+json",
+    };
+    const signer = await getInstanceFetchSignerByDb(db);
+    if (signer) {
+      Object.assign(
+        headers,
+        await signRequest(signer.privateKeyPem, signer.keyId, "GET", objectId),
+      );
+    }
+    const res = await fetchWithTimeout(objectId, {
+      headers,
+      timeout: ANNOUNCED_OBJECT_FETCH_TIMEOUT_MS,
+    });
+    if (!res.ok) return false;
+    const raw: unknown = await res.json();
+    if (!raw || typeof raw !== "object") return false;
+    note = raw as ActivityObject & { attributedTo?: unknown };
+  } catch {
+    // Unresolvable / oversized / timed-out fetch: drop silently (the caller
+    // logs at debug level), matching the pre-existing unknown-object behavior.
+    return false;
+  }
+
+  if (note.id !== objectId) return false;
+  if (!typeIncludes(note.type, "Note")) return false;
+
+  const attributedTo =
+    typeof note.attributedTo === "string" ? note.attributedTo : null;
+  if (!attributedTo || !isSafeRemoteUrl(attributedTo)) return false;
+  try {
+    if (getDomain(attributedTo) !== getDomain(objectId)) return false;
+  } catch {
+    return false;
+  }
+
+  // Addressing gates: a DM-shaped object must never be stored world-readable,
+  // and a non-public classification is refused outright (see doc comment).
+  if (isDirectShapedNote(note)) return false;
+  const visibility = classifyInboundNoteVisibility(note);
+  if (visibility !== "public" && visibility !== "unlisted") return false;
+
+  // Best-effort author profile fill so the surfaced boost renders with the
+  // author's name/icon. Cache-when-absent; a failure never blocks the persist.
+  const cachedAuthor = await db
+    .select({ apId: actorCache.apId })
+    .from(actorCache)
+    .where(eq(actorCache.apId, attributedTo))
+    .get();
+  if (!cachedAuthor) {
+    try {
+      await fetchAndUpsertActorCache(db, attributedTo, {
+        timeout: ANNOUNCED_OBJECT_FETCH_TIMEOUT_MS,
+        mode: "insert",
+        signer: (await getInstanceFetchSignerByDb(db)) ?? undefined,
+      });
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  const attachments = note.attachment ? JSON.stringify(note.attachment) : "[]";
+  await db
+    .insert(objects)
+    .values({
+      apId: objectId,
+      type: "Note",
+      attributedTo,
+      content: boundInboundContent(note.content),
+      summary: boundInboundSummary(note.summary),
+      attachmentsJson: boundAttachmentsJson(attachments),
+      // Stored verbatim, never resolved (depth cap): a boosted reply keeps its
+      // honest thread link even though the parent may stay unknown here.
+      inReplyTo: note.inReplyTo || null,
+      visibility,
+      toJson: boundAddressJson(note.to),
+      ccJson: boundAddressJson(note.cc),
+      communityApId: null,
+      published: normalizeInboundTimestamp(
+        note.published,
+        new Date().toISOString(),
+      ),
+      isLocal: 0,
+    })
+    .onConflictDoNothing();
+
+  return true;
+}
+
 // ---------------------------------------------------------------------------
 // Delete handler
 // ---------------------------------------------------------------------------

package/src/backend/routes/activitypub/handlers/inbox-follow-handlers.ts

@@ -1,12 +1,6 @@
 import type { Database } from "../../../../db/index.ts";
-import { and, eq, gt, inArray, sql } from "drizzle-orm";
-import {
-  activities,
-  actors,
-  follows,
-  likes,
-  objects,
-} from "../../../../db/index.ts";
+import { and, eq, gt, or, sql } from "drizzle-orm";
+import { activities, actors, follows } from "../../../../db/index.ts";
 import {
   activityApId,
   generateId,
@@ -43,6 +37,7 @@ export async function handleFollow(
   recipient: ActorRow,
   actor: string,
   baseUrl: string,
+  sourceActivityId: string = activity.id || "",
 ) {
   const db = c.get("db");
 
@@ -152,7 +147,9 @@ export async function handleFollow(
       id: acceptId,
       type: "Accept",
       actor: recipient.apId,
-      object: activityId,
+      // Echo the peer's bounded protocol id, not our origin-bound internal
+      // ledger id. Remote servers match Accept.object to their Follow id.
+      object: sourceActivityId || activityId,
     };
 
     // Store accept activity before enqueue.
@@ -160,7 +157,7 @@ export async function handleFollow(
       apId: acceptId,
       type: "Accept",
       actorApId: recipient.apId,
-      objectApId: activityId,
+      objectApId: sourceActivityId || activityId,
       rawJson: JSON.stringify(acceptActivity),
       direction: "outbound",
     });
@@ -294,10 +291,20 @@ export async function handleReject(
 // Undo handler
 // ---------------------------------------------------------------------------
 
+/**
+ * `recipient` is null when the Undo arrived at the shared inbox as an
+ * INSTANCE-scoped activity — i.e. Undo(Like|Announce), which is actor-keyed
+ * and idempotent and names no local actor. Undo(Follow|Block) is object-actor
+ * scoped and always dispatched with its resolved target, so a null recipient
+ * on a follow branch means the target could not be resolved; that is logged
+ * and refused rather than guessed at. The previous code guessed: it fell back
+ * to deleting the signer's likes across EVERY object the "recipient" had
+ * authored and rewriting every one of that actor's `objects` rows.
+ */
 export async function handleUndo(
   c: ActivityContext,
   activity: Activity,
-  recipient: ActorRow,
+  recipient: ActorRow | null,
   actor: string,
   _baseUrl: string,
 ) {
@@ -318,9 +325,17 @@ export async function handleUndo(
   }
 
   if (typeIncludes(objectType, "Follow")) {
+    if (!recipient) {
+      log.warn("Undo(Follow) without a resolved local target", {
+        event: "ap.undo.follow.no_recipient",
+        actor,
+        activityId: activity.id,
+      });
+      return;
+    }
     await undoFollow(db, objectId, actor, recipient);
   } else if (typeIncludes(objectType, "Like")) {
-    await undoLike(db, objectId, activityObject, actor, recipient);
+    await undoLike(db, objectId, activityObject, actor);
   } else if (typeIncludes(objectType, "Announce")) {
     await undoAnnounce(db, objectId, activityObject, actor);
   }
@@ -339,16 +354,25 @@ async function resolveUndoByActivityId(
   db: Database,
   objectId: string,
   actor: string,
-  recipient: ActorRow,
+  recipient: ActorRow | null,
 ): Promise<boolean> {
   const originalActivity = await db
     .select({
+      apId: activities.apId,
       type: activities.type,
       objectApId: activities.objectApId,
       actorApId: activities.actorApId,
     })
     .from(activities)
-    .where(eq(activities.apId, objectId))
+    .where(
+      or(
+        eq(activities.apId, objectId),
+        and(
+          eq(activities.direction, "inbound"),
+          sql`json_extract(${activities.rawJson}, '$.id') = ${objectId}`,
+        ),
+      ),
+    )
     .get();
   if (!originalActivity) return false;
 
@@ -363,7 +387,17 @@ async function resolveUndoByActivityId(
   }
 
   if (originalActivity.type === "Follow") {
-    const follow = await findFollowByActivityId(db, objectId);
+    // The followerCount decrement is keyed on the followed actor, so an
+    // instance-dispatched Undo (no resolved local target) must not run it.
+    if (!recipient) {
+      log.warn("Undo(Follow) by activity id without a resolved local target", {
+        event: "ap.undo.follow.no_recipient",
+        actor,
+        activityId: objectId,
+      });
+      return true;
+    }
+    const follow = await findFollowByActivityId(db, originalActivity.apId);
     if (follow) {
       await undoFollowEdge(
         db,
@@ -391,7 +425,14 @@ async function resolveUndoByActivityId(
     // A crash-then-retry converges (the recompute is idempotent against the true
     // edge set) instead of permanently over-counting on the retry's no-op
     // delete. The actor-mismatch guard above still constrains who may undo.
-    await undoInteraction(db, kind, countField, undefined, objectId, actor);
+    await undoInteraction(
+      db,
+      kind,
+      countField,
+      undefined,
+      originalActivity.apId,
+      actor,
+    );
     return true;
   }
 
@@ -476,12 +517,26 @@ async function undoFollow(
   await undoFollowEdge(db, followerApId, followingApId, recipient.apId);
 }
 
+/**
+ * Undo(Like).
+ *
+ * If the like edge cannot be identified — from the inner object's `object`, or
+ * from the referenced Like activity id — there is NOTHING to undo and we say
+ * so. There used to be a "last resort" here that deleted every like the signer
+ * held on ANY object authored by the delivery recipient and then recomputed
+ * `likeCount` for EVERY one of that actor's `objects` rows. It was reachable
+ * from a malformed `{type:'Undo', object:{type:'Like', id:...}}` with no inner
+ * `object` (and from the actor-mismatch branch), and under the shared inbox it
+ * ran once per local follower, so a single non-conformant peer could both wipe
+ * a user's likes across an author's whole timeline and amplify a full-table
+ * UPDATE by the follower count. Nothing about the activity authorised that
+ * scope: the only thing it identified was the signer.
+ */
 async function undoLike(
   db: Database,
   objectId: string | null,
   activityObject: ReturnType<typeof getActivityObject>,
   actor: string,
-  recipient: ActorRow,
 ): Promise<void> {
   const handled = await undoInteraction(
     db,
@@ -493,43 +548,13 @@ async function undoLike(
   );
   if (handled) return;
 
-  // Last resort: delete any like from this actor for the recipient's objects.
-  // #COUNTER-SYM: co-commit the edge delete and a COUNT(*) recompute of likeCount
-  // in one atomic batch (mirrors the primary undoInteraction path). Previously
-  // the delete committed first and the count was decremented (`- 1`) in a
-  // SEPARATE statement; a crash between them, then a peer retry whose delete
-  // matches 0 rows, permanently SKIPPED the decrement → a like OVER-count.
-  // Deriving each affected object's likeCount from COUNT(*) of the remaining like
-  // rows makes the fallback idempotent so a crash-then-retry CONVERGES instead of
-  // drifting.
-  // The recipient (local user) can have authored thousands of objects; splicing
-  // every id into an `IN (...)` would blow D1's 100-bound-parameter ceiling.
-  // Express the affected set as a SUBQUERY (delete) and a direct predicate
-  // (update) so no per-object parameter is bound. An empty set is a harmless
-  // no-op batch, so the previous early-return is unnecessary.
-  const recipientObjectsSubquery = db
-    .select({ apId: objects.apId })
-    .from(objects)
-    .where(eq(objects.attributedTo, recipient.apId));
-
-  await runBatch(db, [
-    db
-      .delete(likes)
-      .where(
-        and(
-          eq(likes.actorApId, actor),
-          inArray(likes.objectApId, recipientObjectsSubquery),
-        ),
-      ),
-    db
-      .update(objects)
-      .set({
-        likeCount: sql`(SELECT COUNT(*) FROM ${likes} WHERE ${likes.objectApId} = ${objects.apId})`,
-      })
-      .where(eq(objects.attributedTo, recipient.apId)),
-  ]);
+  log.warn("Undo(Like) names no resolvable like edge; ignoring", {
+    event: "ap.undo.like.unresolved",
+    actor,
+    activityId: objectId,
+    object: activityObject?.object,
+  });
 }
-
 async function undoAnnounce(
   db: Database,
   objectId: string | null,

package/src/backend/routes/activitypub/handlers/inbox-interaction-handlers.ts

@@ -20,7 +20,9 @@ import {
   getActivityObjectId,
 } from "../inbox-types.ts";
 import { notifyLocalObjectOwner } from "./inbox-shared-helpers.ts";
+import { fetchAndPersistAnnouncedNote } from "./inbox-content-handlers.ts";
 import { isLocal } from "../../../lib/ap-ids.ts";
+import { notDeleted } from "../../../../db/index.ts";
 import {
   actorIsBlockedBy,
   canViewerReadObjectFull,
@@ -174,10 +176,15 @@ async function handleInteraction(
 // Like handler
 // ---------------------------------------------------------------------------
 
+/**
+ * A Like is INSTANCE-scoped: the affected object (and the local owner to
+ * notify) is resolved from `activity.object`, never from a delivery recipient.
+ * The recipient argument was already ignored; removing it is what stops the
+ * shared inbox from being able to run this once per local follower.
+ */
 export async function handleLike(
   c: ActivityContext,
   activity: Activity,
-  _recipient: ActorRow,
   actor: string,
   baseUrl: string,
 ) {
@@ -188,13 +195,70 @@ export async function handleLike(
 // Announce handler (repost/boost)
 // ---------------------------------------------------------------------------
 
+/**
+ * Does at least one (non-tombstoned) LOCAL actor have an accepted follow of
+ * `actorApId`? The fetch-and-store path below is gated on this so an arbitrary
+ * remote cannot use our inbox as an open relay: only a boost from someone a
+ * local user chose to follow may trigger an outbound object fetch.
+ */
+async function actorHasLocalFollowers(
+  db: Database,
+  actorApId: string,
+): Promise<boolean> {
+  const row = await db
+    .select({ followerApId: follows.followerApId })
+    .from(follows)
+    .innerJoin(
+      actors,
+      and(eq(actors.apId, follows.followerApId), notDeleted(actors)),
+    )
+    .where(
+      and(eq(follows.followingApId, actorApId), eq(follows.status, "accepted")),
+    )
+    .limit(1)
+    .get();
+  return Boolean(row);
+}
+
+/** Instance-scoped, exactly like {@link handleLike}. */
 export async function handleAnnounce(
   c: ActivityContext,
   activity: Activity,
-  _recipient: ActorRow,
   actor: string,
   baseUrl: string,
 ) {
+  // Fetch-and-store an UNKNOWN boosted remote object before recording the
+  // announce, so a followed remote's boost of a post this instance never saw
+  // still surfaces in feeds (previously the Announce only left a dangling
+  // announce edge + a counter no-op). Strictly gated: the target must be
+  // remote and unknown, and the booster must have at least one local follower
+  // (no open-relay amplification). On any fetch/validation failure the
+  // Announce degrades to exactly the old behavior — handleInteraction records
+  // the edge idempotently and the counter recompute no-ops on the absent row,
+  // so a later Create of the same object retroactively completes the boost.
+  const db = c.get("db");
+  const objectId = getActivityObjectId(activity);
+  if (objectId && !isLocal(objectId, baseUrl)) {
+    const known = await db
+      .select({ apId: objects.apId })
+      .from(objects)
+      .where(eq(objects.apId, objectId))
+      .get();
+    if (!known && (await actorHasLocalFollowers(db, actor))) {
+      const persisted = await fetchAndPersistAnnouncedNote(
+        db,
+        objectId,
+        baseUrl,
+      );
+      if (!persisted) {
+        log.debug("Announce target fetch skipped or failed", {
+          event: "ap.announce.object_fetch_failed",
+          actor,
+          objectId,
+        });
+      }
+    }
+  }
   await handleInteraction("announce", c, activity, actor, baseUrl);
 }
 

package/src/backend/routes/activitypub/handlers/inbox-shared-helpers.ts

@@ -23,18 +23,13 @@ import type { Activity } from "../inbox-types.ts";
 // ---------------------------------------------------------------------------
 
 type BatchStatement = BatchItem<"sqlite">;
-interface BatchableDb {
-  batch(
-    statements: readonly [BatchStatement, ...BatchStatement[]],
-  ): Promise<unknown>;
-}
 
-export async function runBatch(
-  db: Database,
-  statements: readonly [BatchStatement, ...BatchStatement[]],
-): Promise<void> {
-  await (db as unknown as BatchableDb).batch(statements);
-}
+// The batch primitive lives with the other D1 write primitives (src/db/
+// d1-write.ts) so the atomicity rule and the parameter-budget rule cannot
+// drift apart. Re-exported here because the inbox handlers are its heaviest
+// caller and this is the import path they already use.
+export { runBatch } from "../../../../db/d1-write.ts";
+import { runBatch } from "../../../../db/d1-write.ts";
 
 // ---------------------------------------------------------------------------
 // Shared helpers used by multiple inbox handler files
@@ -97,7 +92,7 @@ export async function findFollowByActivityId(
   followingApId: string;
   status: string;
 } | null> {
-  const row = await db
+  let row = await db
     .select({
       followerApId: follows.followerApId,
       followingApId: follows.followingApId,
@@ -106,6 +101,34 @@ export async function findFollowByActivityId(
     .from(follows)
     .where(eq(follows.activityApId, activityApIdValue))
     .get();
+  if (!row) {
+    // Inbound envelopes use an origin-bound internal activities.apId. Undo
+    // carries the peer's protocol id, so resolve that bounded raw-json id back
+    // to the internal row before looking up the follow edge. The direct lookup
+    // above preserves compatibility with legacy rows.
+    const source = await db
+      .select({ apId: activities.apId })
+      .from(activities)
+      .where(
+        and(
+          eq(activities.direction, "inbound"),
+          sql`json_extract(${activities.rawJson}, '$.id') = ${activityApIdValue}`,
+        ),
+      )
+      .limit(2);
+    for (const candidate of source) {
+      row = await db
+        .select({
+          followerApId: follows.followerApId,
+          followingApId: follows.followingApId,
+          status: follows.status,
+        })
+        .from(follows)
+        .where(eq(follows.activityApId, candidate.apId))
+        .get();
+      if (row) break;
+    }
+  }
   return row ?? null;
 }