@rmdes/indiekit-endpoint-activitypub 2.13.0 → 2.15.0

package/lib/inbox-listeners.js

@@ -1,15 +1,17 @@
 /**
  * Inbox listener registrations for the Fedify Federation instance.
  *
- * Each listener handles a specific ActivityPub activity type received
- * in the actor's inbox (Follow, Undo, Like, Announce, Create, Delete, Move).
+ * Each listener is a thin shim that:
+ * 1. Checks server-level blocks (Redis, O(1))
+ * 2. Updates key freshness tracking
+ * 3. Performs synchronous-only work (Follow Accept, Block follower removal)
+ * 4. Enqueues the activity for async processing
  */
 
 import {
   Accept,
   Add,
   Announce,
-  Article,
   Block,
   Create,
   Delete,
@@ -17,20 +19,18 @@ import {
   Follow,
   Like,
   Move,
-  Note,
   Reject,
   Remove,
   Undo,
   Update,
 } from "@fedify/fedify/vocab";
 
-import { logActivity as logActivityShared } from "./activity-log.js";
-import { sanitizeContent, extractActorInfo, extractObjectData } from "./timeline-store.js";
-import { addTimelineItem, deleteTimelineItem, updateTimelineItem } from "./storage/timeline.js";
+import { isServerBlocked } from "./storage/server-blocks.js";
+import { touchKeyFreshness } from "./key-refresh.js";
+import { resetDeliveryStrikes } from "./outbox-failure.js";
+import { enqueueActivity } from "./inbox-queue.js";
+import { extractActorInfo } from "./timeline-store.js";
 import { addNotification } from "./storage/notifications.js";
-import { addMessage } from "./storage/messages.js";
-import { fetchAndStorePreviews, fetchAndStoreQuote } from "./og-unfurl.js";
-import { getFollowedTags } from "./storage/followed-tags.js";
 
 /**
  * Register all inbox listeners on a federation's inbox chain.
@@ -41,54 +41,21 @@ import { getFollowedTags } from "./storage/followed-tags.js";
  * @param {string} options.handle - Actor handle
  * @param {boolean} options.storeRawActivities - Whether to store raw JSON
  */
-/** @type {string} ActivityStreams Public Collection constant */
-const PUBLIC = "https://www.w3.org/ns/activitystreams#Public";
-
-/**
- * Determine if an object is a direct message (DM).
- * A DM is addressed only to specific actors — no PUBLIC_COLLECTION,
- * no followers collection, and includes our actor URL.
- *
- * @param {object} object - Fedify object (Note, Article, etc.)
- * @param {string} ourActorUrl - Our actor's URL
- * @param {string} followersUrl - Our followers collection URL
- * @returns {boolean}
- */
-function isDirectMessage(object, ourActorUrl, followersUrl) {
-  const allAddressed = [
-    ...object.toIds.map((u) => u.href),
-    ...object.ccIds.map((u) => u.href),
-    ...object.btoIds.map((u) => u.href),
-    ...object.bccIds.map((u) => u.href),
-  ];
-
-  // Must be addressed to us
-  if (!allAddressed.includes(ourActorUrl)) return false;
-
-  // Must NOT include public collection
-  if (allAddressed.some((u) => u === PUBLIC || u === "as:Public")) return false;
-
-  // Must NOT include our followers collection
-  if (followersUrl && allAddressed.includes(followersUrl)) return false;
-
-  return true;
-}
-
 export function registerInboxListeners(inboxChain, options) {
-  const { collections, handle, storeRawActivities } = options;
-
-  /**
-   * Get an authenticated DocumentLoader that signs outbound fetches with
-   * our actor's key. This allows .getActor()/.getObject() to succeed
-   * against Authorized Fetch (Secure Mode) servers like hachyderm.io.
-   *
-   * @param {import("@fedify/fedify").Context} ctx - Fedify context
-   * @returns {Promise<import("@fedify/fedify").DocumentLoader>}
-   */
+  const { collections, handle } = options;
+
   const getAuthLoader = (ctx) => ctx.getDocumentLoader({ identifier: handle });
 
   inboxChain
+    // ── Follow ──────────────────────────────────────────────────────
+    // Synchronous: Accept/Reject + follower storage (federation requirement)
+    // Async: notification + activity log
     .on(Follow, async (ctx, follow) => {
+      const actorUrl = follow.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
+
       const authLoader = await getAuthLoader(ctx);
       const followerActor = await follow.getActor({ documentLoader: authLoader });
       if (!followerActor?.id) return;
@@ -99,7 +66,6 @@ export function registerInboxListeners(inboxChain, options) {
         followerActor.preferredUsername?.toString() ||
         followerUrl;
 
-      // Build common follower data
       const followerData = {
         actorUrl: followerUrl,
         handle: followerActor.preferredUsername?.toString() || "",
@@ -111,12 +77,10 @@ export function registerInboxListeners(inboxChain, options) {
         sharedInbox: followerActor.endpoints?.sharedInbox?.href || "",
       };
 
-      // Check if manual approval is enabled
       const profile = await collections.ap_profile.findOne({});
       const manualApproval = profile?.manuallyApprovesFollowers || false;
 
       if (manualApproval && collections.ap_pending_follows) {
-        // Store as pending — do NOT send Accept yet
         await collections.ap_pending_follows.updateOne(
           { actorUrl: followerUrl },
           {
@@ -129,15 +93,7 @@ export function registerInboxListeners(inboxChain, options) {
           { upsert: true },
         );
 
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Follow",
-          actorUrl: followerUrl,
-          actorName: followerName,
-          summary: `${followerName} requested to follow you`,
-        });
-
-        // Notification with type "follow_request"
+        // Notification for follow request (synchronous — needed for UI)
         const followerInfo = await extractActorInfo(followerActor, { documentLoader: authLoader });
         await addNotification(collections, {
           uid: follow.id?.href || `follow_request:${followerUrl}`,
@@ -150,7 +106,6 @@ export function registerInboxListeners(inboxChain, options) {
           createdAt: new Date().toISOString(),
         });
       } else {
-        // Auto-accept: store follower + send Accept back
         await collections.ap_followers.updateOne(
           { actorUrl: followerUrl },
           {
@@ -172,15 +127,7 @@ export function registerInboxListeners(inboxChain, options) {
           { orderingKey: followerUrl },
         );
 
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Follow",
-          actorUrl: followerUrl,
-          actorName: followerName,
-          summary: `${followerName} followed you`,
-        });
-
-        // Store notification
+        // Notification for follow (synchronous — needed for UI)
         const followerInfo = await extractActorInfo(followerActor, { documentLoader: authLoader });
         await addNotification(collections, {
           uid: follow.id?.href || `follow:${followerUrl}`,
@@ -193,680 +140,217 @@ export function registerInboxListeners(inboxChain, options) {
           createdAt: new Date().toISOString(),
         });
       }
+
+      // Enqueue async portion (activity log)
+      await enqueueActivity(collections, {
+        activityType: "Follow",
+        actorUrl,
+        rawJson: await follow.toJsonLd(),
+      });
     })
+
+    // ── Undo ────────────────────────────────────────────────────────
     .on(Undo, async (ctx, undo) => {
       const actorUrl = undo.actorId?.href || "";
-      const authLoader = await getAuthLoader(ctx);
-      let inner;
-      try {
-        inner = await undo.getObject({ documentLoader: authLoader });
-      } catch {
-        // Inner activity not dereferenceable — can't determine what was undone
-        return;
-      }
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      if (inner instanceof Follow) {
-        await collections.ap_followers.deleteOne({ actorUrl });
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Undo(Follow)",
-          actorUrl,
-          summary: `${actorUrl} unfollowed you`,
-        });
-      } else if (inner instanceof Like) {
-        const objectId = inner.objectId?.href || "";
-        await collections.ap_activities.deleteOne({
-          type: "Like",
-          actorUrl,
-          objectUrl: objectId,
-        });
-      } else if (inner instanceof Announce) {
-        const objectId = inner.objectId?.href || "";
-        await collections.ap_activities.deleteOne({
-          type: "Announce",
-          actorUrl,
-          objectUrl: objectId,
-        });
-      } else {
-        const typeName = inner?.constructor?.name || "unknown";
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: `Undo(${typeName})`,
-          actorUrl,
-          summary: `${actorUrl} undid ${typeName}`,
-        });
-      }
+      await enqueueActivity(collections, {
+        activityType: "Undo",
+        actorUrl,
+        rawJson: await undo.toJsonLd(),
+      });
     })
+
+    // ── Accept ──────────────────────────────────────────────────────
     .on(Accept, async (ctx, accept) => {
-      // Handle Accept(Follow) — remote server accepted our Follow request.
-      // We don't inspect the inner object type because Fedify often resolves
-      // it to a Person (the Follow's target) rather than the Follow itself.
-      // Instead, we match directly against ap_following — if we have a
-      // pending follow for this actor, any Accept from them confirms it.
-      const authLoader = await getAuthLoader(ctx);
-      const actorObj = await accept.getActor({ documentLoader: authLoader });
-      const actorUrl = actorObj?.id?.href || "";
-      if (!actorUrl) return;
-
-      const result = await collections.ap_following.findOneAndUpdate(
-        {
-          actorUrl,
-          source: { $in: ["refollow:sent", "reader", "microsub-reader"] },
-        },
-        {
-          $set: {
-            source: "federation",
-            acceptedAt: new Date().toISOString(),
-          },
-          $unset: {
-            refollowAttempts: "",
-            refollowLastAttempt: "",
-            refollowError: "",
-          },
-        },
-        { returnDocument: "after" },
-      );
-
-      if (result) {
-        const actorName =
-          result.name || result.handle || actorUrl;
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Accept(Follow)",
-          actorUrl,
-          actorName,
-          summary: `${actorName} accepted our Follow`,
-        });
-      }
+      const actorUrl = accept.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
+
+      await enqueueActivity(collections, {
+        activityType: "Accept",
+        actorUrl,
+        rawJson: await accept.toJsonLd(),
+      });
     })
+
+    // ── Reject ──────────────────────────────────────────────────────
     .on(Reject, async (ctx, reject) => {
-      const authLoader = await getAuthLoader(ctx);
-      const actorObj = await reject.getActor({ documentLoader: authLoader });
-      const actorUrl = actorObj?.id?.href || "";
-      if (!actorUrl) return;
-
-      // Mark rejected follow in ap_following
-      const result = await collections.ap_following.findOneAndUpdate(
-        {
-          actorUrl,
-          source: { $in: ["refollow:sent", "reader", "microsub-reader"] },
-        },
-        {
-          $set: {
-            source: "rejected",
-            rejectedAt: new Date().toISOString(),
-          },
-        },
-        { returnDocument: "after" },
-      );
-
-      if (result) {
-        const actorName = result.name || result.handle || actorUrl;
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Reject(Follow)",
-          actorUrl,
-          actorName,
-          summary: `${actorName} rejected our Follow`,
-        });
-      }
-    })
-    .on(Like, async (ctx, like) => {
-      // Use .objectId (non-fetching) for the liked URL — we only need the
-      // URL to filter and log, not the full remote object.
-      const objectId = like.objectId?.href || "";
+      const actorUrl = reject.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      // Only log likes of our own content
-      const pubUrl = collections._publicationUrl;
-      if (!objectId || (pubUrl && !objectId.startsWith(pubUrl))) return;
+      await enqueueActivity(collections, {
+        activityType: "Reject",
+        actorUrl,
+        rawJson: await reject.toJsonLd(),
+      });
+    })
 
-      const authLoader = await getAuthLoader(ctx);
+    // ── Like ────────────────────────────────────────────────────────
+    .on(Like, async (ctx, like) => {
       const actorUrl = like.actorId?.href || "";
-      let actorObj;
-      try {
-        actorObj = await like.getActor({ documentLoader: authLoader });
-      } catch {
-        actorObj = null;
-      }
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      const actorName =
-        actorObj?.name?.toString() ||
-        actorObj?.preferredUsername?.toString() ||
-        actorUrl;
-
-      // Extract actor info (including avatar) before logging so we can store it
-      const actorInfo = await extractActorInfo(actorObj, { documentLoader: authLoader });
-
-      await logActivity(collections, storeRawActivities, {
-        direction: "inbound",
-        type: "Like",
+      await enqueueActivity(collections, {
+        activityType: "Like",
         actorUrl,
-        actorName,
-        actorAvatar: actorInfo.photo || "",
-        objectUrl: objectId,
-        summary: `${actorName} liked ${objectId}`,
-      });
-
-      // Store notification
-      await addNotification(collections, {
-        uid: like.id?.href || `like:${actorUrl}:${objectId}`,
-        type: "like",
-        actorUrl: actorInfo.url,
-        actorName: actorInfo.name,
-        actorPhoto: actorInfo.photo,
-        actorHandle: actorInfo.handle,
-        targetUrl: objectId,
-        targetName: "", // Could fetch post title, but not critical
-        published: like.published ? String(like.published) : new Date().toISOString(),
-        createdAt: new Date().toISOString(),
+        objectUrl: like.objectId?.href || "",
+        rawJson: await like.toJsonLd(),
       });
     })
-    .on(Announce, async (ctx, announce) => {
-      const objectId = announce.objectId?.href || "";
-      if (!objectId) return;
 
-      const authLoader = await getAuthLoader(ctx);
+    // ── Announce ────────────────────────────────────────────────────
+    .on(Announce, async (ctx, announce) => {
       const actorUrl = announce.actorId?.href || "";
-      const pubUrl = collections._publicationUrl;
-
-      // Dual path logic: Notification vs Timeline
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      // PATH 1: Boost of OUR content → Notification
-      if (pubUrl && objectId.startsWith(pubUrl)) {
-        let actorObj;
-        try {
-          actorObj = await announce.getActor({ documentLoader: authLoader });
-        } catch {
-          actorObj = null;
-        }
-
-        const actorName =
-          actorObj?.name?.toString() ||
-          actorObj?.preferredUsername?.toString() ||
-          actorUrl;
-
-        // Extract actor info (including avatar) before logging so we can store it
-        const actorInfo = await extractActorInfo(actorObj, { documentLoader: authLoader });
-
-        // Log the boost activity
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Announce",
-          actorUrl,
-          actorName,
-          actorAvatar: actorInfo.photo || "",
-          objectUrl: objectId,
-          summary: `${actorName} boosted ${objectId}`,
-        });
-
-        // Create notification
-        await addNotification(collections, {
-          uid: announce.id?.href || `${actorUrl}#boost-${objectId}`,
-          type: "boost",
-          actorUrl: actorInfo.url,
-          actorName: actorInfo.name,
-          actorPhoto: actorInfo.photo,
-          actorHandle: actorInfo.handle,
-          targetUrl: objectId,
-          targetName: "", // Could fetch post title, but not critical
-          published: announce.published ? String(announce.published) : new Date().toISOString(),
-          createdAt: new Date().toISOString(),
-        });
-
-        // Don't return — fall through to check if actor is also followed
-      }
-
-      // PATH 2: Boost from someone we follow → Timeline (store original post)
-      const following = await collections.ap_following.findOne({ actorUrl });
-      if (following) {
-        try {
-          // Fetch the original object being boosted (authenticated for Secure Mode servers)
-          const object = await announce.getObject({ documentLoader: authLoader });
-          if (!object) return;
-
-          // Skip non-content objects (Lemmy/PieFed like/create activities
-          // that resolve to activity IDs instead of actual Note/Article posts)
-          const hasContent = object.content?.toString() || object.name?.toString();
-          if (!hasContent) return;
-
-          // Get booster actor info
-          const boosterActor = await announce.getActor({ documentLoader: authLoader });
-          const boosterInfo = await extractActorInfo(boosterActor, { documentLoader: authLoader });
-
-          // Extract and store with boost metadata
-          const timelineItem = await extractObjectData(object, {
-            boostedBy: boosterInfo,
-            boostedAt: announce.published ? String(announce.published) : new Date().toISOString(),
-            documentLoader: authLoader,
-          });
-
-          await addTimelineItem(collections, timelineItem);
-
-          // Fire-and-forget quote enrichment for boosted posts
-          if (timelineItem.quoteUrl) {
-            fetchAndStoreQuote(collections, timelineItem.uid, timelineItem.quoteUrl, ctx, authLoader)
-              .catch((error) => {
-                console.error(`[inbox] Quote fetch failed for ${timelineItem.uid}:`, error.message);
-              });
-          }
-        } catch (error) {
-          // Remote object unreachable (timeout, Authorized Fetch, deleted, etc.) — skip
-          const cause = error?.cause?.code || error?.message || "unknown";
-          console.warn(`[AP] Skipped boost from ${actorUrl}: ${cause}`);
-        }
-      }
+      await enqueueActivity(collections, {
+        activityType: "Announce",
+        actorUrl,
+        objectUrl: announce.objectId?.href || "",
+        rawJson: await announce.toJsonLd(),
+      });
     })
-    .on(Create, async (ctx, create) => {
-      const authLoader = await getAuthLoader(ctx);
-      let object;
-      try {
-        object = await create.getObject({ documentLoader: authLoader });
-      } catch {
-        // Remote object not dereferenceable (deleted, etc.)
-        return;
-      }
-      if (!object) return;
 
+    // ── Create ──────────────────────────────────────────────────────
+    .on(Create, async (ctx, create) => {
       const actorUrl = create.actorId?.href || "";
-      let actorObj;
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
+
+      // Forward public replies to our posts to our followers.
+      // Must happen here (not in async handler) because forwardActivity
+      // is only available on InboxContext, not base Context.
+      const objectUrl = create.objectId?.href || "";
       try {
-        actorObj = await create.getActor({ documentLoader: authLoader });
-      } catch {
-        // Actor not dereferenceable — use URL as fallback
-        actorObj = null;
-      }
-      const actorName =
-        actorObj?.name?.toString() ||
-        actorObj?.preferredUsername?.toString() ||
-        actorUrl;
-
-      // --- DM detection ---
-      // Check if this is a direct message before processing as reply/mention/timeline.
-      // DMs are handled separately and stored in ap_messages instead of ap_timeline.
-      const ourActorUrl = ctx.getActorUri(handle).href;
-      const followersUrl = ctx.getFollowersUri(handle)?.href || "";
-
-      if (isDirectMessage(object, ourActorUrl, followersUrl)) {
-        const actorInfo = await extractActorInfo(actorObj, { documentLoader: authLoader });
-        const rawHtml = object.content?.toString() || "";
-        const contentHtml = sanitizeContent(rawHtml);
-        const contentText = rawHtml.replace(/<[^>]*>/g, "").substring(0, 500);
-        const published = object.published ? String(object.published) : new Date().toISOString();
-        const inReplyToDM = object.replyTargetId?.href || null;
-
-        // Store as message
-        await addMessage(collections, {
-          uid: object.id?.href || `dm:${actorUrl}:${Date.now()}`,
-          actorUrl: actorInfo.url,
-          actorName: actorInfo.name,
-          actorPhoto: actorInfo.photo,
-          actorHandle: actorInfo.handle,
-          content: {
-            text: contentText,
-            html: contentHtml,
-          },
-          inReplyTo: inReplyToDM,
-          conversationId: actorInfo.url,
-          direction: "inbound",
-          published,
-          createdAt: new Date().toISOString(),
-        });
-
-        // Also create a notification so DMs appear in the notification tab
-        await addNotification(collections, {
-          uid: `dm:${object.id?.href || `${actorUrl}:${Date.now()}`}`,
-          url: object.url?.href || object.id?.href || "",
-          type: "dm",
-          actorUrl: actorInfo.url,
-          actorName: actorInfo.name,
-          actorPhoto: actorInfo.photo,
-          actorHandle: actorInfo.handle,
-          content: {
-            text: contentText,
-            html: contentHtml,
-          },
-          published,
-          createdAt: new Date().toISOString(),
-        });
-
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "DirectMessage",
-          actorUrl,
-          actorName,
-          actorAvatar: actorInfo.photo || "",
-          objectUrl: object.id?.href || "",
-          content: contentText.substring(0, 100),
-          summary: `${actorName} sent a direct message`,
-        });
-
-        return; // Don't process DMs as timeline/mention/reply
-      }
-
-      // Use replyTargetId (non-fetching) for the inReplyTo URL
-      const inReplyTo = object.replyTargetId?.href || null;
-
-      // Log replies to our posts (existing behavior for conversations)
-      const pubUrl = collections._publicationUrl;
-      if (inReplyTo) {
-        const content = object.content?.toString() || "";
-
-        // Extract actor info (including avatar) before logging so we can store it
-        const actorInfo = await extractActorInfo(actorObj, { documentLoader: authLoader });
-
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Reply",
-          actorUrl,
-          actorName,
-          actorAvatar: actorInfo.photo || "",
-          objectUrl: object.id?.href || "",
-          targetUrl: inReplyTo,
-          content,
-          summary: `${actorName} replied to ${inReplyTo}`,
-        });
-
-        // Create notification if reply is to one of OUR posts
-        if (pubUrl && inReplyTo.startsWith(pubUrl)) {
-          const rawHtml = object.content?.toString() || "";
-          const contentHtml = sanitizeContent(rawHtml);
-          const contentText = rawHtml.replace(/<[^>]*>/g, "").substring(0, 200);
-
-          await addNotification(collections, {
-            uid: object.id?.href || `reply:${actorUrl}:${inReplyTo}`,
-            url: object.url?.href || object.id?.href || "",
-            type: "reply",
-            actorUrl: actorInfo.url,
-            actorName: actorInfo.name,
-            actorPhoto: actorInfo.photo,
-            actorHandle: actorInfo.handle,
-            targetUrl: inReplyTo,
-            targetName: "",
-            content: {
-              text: contentText,
-              html: contentHtml,
-            },
-            published: object.published ? String(object.published) : new Date().toISOString(),
-            createdAt: new Date().toISOString(),
-          });
-        }
-      }
-
-      // Check for mentions of our actor
-      if (object.tag) {
-        const tags = Array.isArray(object.tag) ? object.tag : [object.tag];
-        const ourActorUrl = ctx.getActorUri(handle).href;
-
-        for (const tag of tags) {
-          if (tag.type === "Mention" && tag.href?.href === ourActorUrl) {
-            const actorInfo = await extractActorInfo(actorObj, { documentLoader: authLoader });
-            const rawMentionHtml = object.content?.toString() || "";
-            const mentionHtml = sanitizeContent(rawMentionHtml);
-            const contentText = rawMentionHtml.replace(/<[^>]*>/g, "").substring(0, 200);
-
-            await addNotification(collections, {
-              uid: object.id?.href || `mention:${actorUrl}:${object.id?.href}`,
-              url: object.url?.href || object.id?.href || "",
-              type: "mention",
-              actorUrl: actorInfo.url,
-              actorName: actorInfo.name,
-              actorPhoto: actorInfo.photo,
-              actorHandle: actorInfo.handle,
-              content: {
-                text: contentText,
-                html: mentionHtml,
+        const obj = await create.getObject();
+        const inReplyTo = obj?.replyTargetId?.href || "";
+        if (
+          inReplyTo &&
+          collections._publicationUrl &&
+          inReplyTo.startsWith(collections._publicationUrl)
+        ) {
+          // Check if the reply is public (to/cc includes PUBLIC collection)
+          const toUrls = (obj.toIds || []).map((u) => u.href);
+          const ccUrls = (obj.ccIds || []).map((u) => u.href);
+          const isPublic = [...toUrls, ...ccUrls].includes(
+            "https://www.w3.org/ns/activitystreams#Public",
+          );
+          if (isPublic) {
+            await ctx.forwardActivity(
+              { identifier: handle },
+              "followers",
+              {
+                skipIfUnsigned: true,
+                preferSharedInbox: true,
+                excludeBaseUris: [new URL(ctx.origin)],
               },
-              published: object.published ? String(object.published) : new Date().toISOString(),
-              createdAt: new Date().toISOString(),
-            });
-
-            break; // Only create one mention notification per post
+            );
           }
         }
+      } catch (error) {
+        // Non-critical — forwarding failure shouldn't block processing
+        console.warn("[inbox-listeners] Reply forwarding failed:", error.message);
       }
 
-      // Store timeline items from accounts we follow (native storage)
-      const following = await collections.ap_following.findOne({ actorUrl });
-      if (following) {
-        try {
-          const timelineItem = await extractObjectData(object, {
-            actorFallback: actorObj,
-            documentLoader: authLoader,
-          });
-          await addTimelineItem(collections, timelineItem);
-
-          // Fire-and-forget OG unfurling for notes and articles (not boosts)
-          if (timelineItem.type === "note" || timelineItem.type === "article") {
-            fetchAndStorePreviews(collections, timelineItem.uid, timelineItem.content.html)
-              .catch((error) => {
-                console.error(`[inbox] OG unfurl failed for ${timelineItem.uid}:`, error);
-              });
-          }
-
-          // Fire-and-forget quote enrichment
-          if (timelineItem.quoteUrl) {
-            fetchAndStoreQuote(collections, timelineItem.uid, timelineItem.quoteUrl, ctx, authLoader)
-              .catch((error) => {
-                console.error(`[inbox] Quote fetch failed for ${timelineItem.uid}:`, error.message);
-              });
-          }
-        } catch (error) {
-          // Log extraction errors but don't fail the entire handler
-          console.error("Failed to store timeline item:", error);
-        }
-      } else if (collections.ap_followed_tags) {
-        // Not a followed account — check if the post's hashtags match any followed tags
-        // so tagged posts from across the fediverse appear in the timeline
-        try {
-          const objectTags = Array.isArray(object.tag) ? object.tag : (object.tag ? [object.tag] : []);
-          const postHashtags = objectTags
-            .filter((t) => t.type === "Hashtag" && t.name)
-            .map((t) => t.name.toString().replace(/^#/, "").toLowerCase());
-
-          if (postHashtags.length > 0) {
-            const followedTags = await getFollowedTags(collections);
-            const followedSet = new Set(followedTags.map((t) => t.toLowerCase()));
-            const hasMatchingTag = postHashtags.some((tag) => followedSet.has(tag));
-
-            if (hasMatchingTag) {
-              const timelineItem = await extractObjectData(object, {
-                actorFallback: actorObj,
-                documentLoader: authLoader,
-              });
-              await addTimelineItem(collections, timelineItem);
-            }
-          }
-        } catch (error) {
-          // Non-critical — don't fail the handler
-          console.error("[inbox] Followed tag check failed:", error.message);
-        }
-      }
-
+      await enqueueActivity(collections, {
+        activityType: "Create",
+        actorUrl,
+        objectUrl,
+        rawJson: await create.toJsonLd(),
+      });
     })
+
+    // ── Delete ──────────────────────────────────────────────────────
     .on(Delete, async (ctx, del) => {
-      const objectId = del.objectId?.href || "";
-      if (objectId) {
-        // Remove from activity log
-        await collections.ap_activities.deleteMany({ objectUrl: objectId });
+      const actorUrl = del.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-        // Remove from timeline
-        await deleteTimelineItem(collections, objectId);
-      }
+      await enqueueActivity(collections, {
+        activityType: "Delete",
+        actorUrl,
+        objectUrl: del.objectId?.href || "",
+        rawJson: await del.toJsonLd(),
+      });
     })
-    .on(Move, async (ctx, move) => {
-      const authLoader = await getAuthLoader(ctx);
-      const oldActorObj = await move.getActor({ documentLoader: authLoader });
-      const oldActorUrl = oldActorObj?.id?.href || "";
-      const target = await move.getTarget({ documentLoader: authLoader });
-      const newActorUrl = target?.id?.href || "";
 
-      if (oldActorUrl && newActorUrl) {
-        await collections.ap_followers.updateOne(
-          { actorUrl: oldActorUrl },
-          { $set: { actorUrl: newActorUrl, movedFrom: oldActorUrl } },
-        );
-      }
+    // ── Move ────────────────────────────────────────────────────────
+    .on(Move, async (ctx, move) => {
+      const actorUrl = move.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      await logActivity(collections, storeRawActivities, {
-        direction: "inbound",
-        type: "Move",
-        actorUrl: oldActorUrl,
-        objectUrl: newActorUrl,
-        summary: `${oldActorUrl} moved to ${newActorUrl}`,
+      await enqueueActivity(collections, {
+        activityType: "Move",
+        actorUrl,
+        rawJson: await move.toJsonLd(),
       });
     })
-    .on(Update, async (ctx, update) => {
-      // Update can be for a profile OR for a post (edited content)
-      const authLoader = await getAuthLoader(ctx);
 
-      // Try to get the object being updated
-      let object;
-      try {
-        object = await update.getObject({ documentLoader: authLoader });
-      } catch {
-        object = null;
-      }
-
-      // PATH 1: If object is a Note/Article → Update timeline item content
-      if (object && (object instanceof Note || object instanceof Article)) {
-        const objectUrl = object.id?.href || "";
-        if (objectUrl) {
-          try {
-            // Extract updated content
-            const contentHtml = object.content?.toString() || "";
-            const contentText = object.source?.content?.toString() || contentHtml.replace(/<[^>]*>/g, "");
-
-            const updates = {
-              content: {
-                text: contentText,
-                html: contentHtml,
-              },
-              name: object.name?.toString() || "",
-              summary: object.summary?.toString() || "",
-              sensitive: object.sensitive || false,
-            };
-
-            await updateTimelineItem(collections, objectUrl, updates);
-          } catch (error) {
-            console.error("Failed to update timeline item:", error);
-          }
-        }
-        return;
-      }
-
-      // PATH 2: Otherwise, assume profile update — refresh stored follower data
-      const actorObj = await update.getActor({ documentLoader: authLoader });
-      const actorUrl = actorObj?.id?.href || "";
-      if (!actorUrl) return;
+    // ── Update ──────────────────────────────────────────────────────
+    .on(Update, async (ctx, update) => {
+      const actorUrl = update.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-      const existing = await collections.ap_followers.findOne({ actorUrl });
-      if (existing) {
-        await collections.ap_followers.updateOne(
-          { actorUrl },
-          {
-            $set: {
-              name:
-                actorObj.name?.toString() ||
-                actorObj.preferredUsername?.toString() ||
-                actorUrl,
-              handle: actorObj.preferredUsername?.toString() || "",
-              avatar: actorObj.icon
-                ? (await actorObj.icon)?.url?.href || ""
-                : "",
-              updatedAt: new Date().toISOString(),
-            },
-          },
-        );
-      }
+      await enqueueActivity(collections, {
+        activityType: "Update",
+        actorUrl,
+        rawJson: await update.toJsonLd(),
+      });
     })
+
+    // ── Block ───────────────────────────────────────────────────────
+    // Synchronous: remove from followers (immediate)
+    // Async: activity log
     .on(Block, async (ctx, block) => {
-      // Remote actor blocked us — remove them from followers
+      const actorUrl = block.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+
+      // Synchronous: remove from followers immediately
       const authLoader = await getAuthLoader(ctx);
       const actorObj = await block.getActor({ documentLoader: authLoader });
-      const actorUrl = actorObj?.id?.href || "";
-      if (actorUrl) {
-        await collections.ap_followers.deleteOne({ actorUrl });
+      const resolvedUrl = actorObj?.id?.href || "";
+      if (resolvedUrl) {
+        await collections.ap_followers.deleteOne({ actorUrl: resolvedUrl });
       }
-    })
-    .on(Add, async () => {
-      // Mastodon uses Add for pinning posts to featured collections — safe to ignore
-    })
-    .on(Remove, async () => {
-      // Mastodon uses Remove for unpinning posts from featured collections — safe to ignore
-    })
-    // ── Flag (Report) ──────────────────────────────────────────────
-    .on(Flag, async (ctx, flag) => {
-      try {
-        const authLoader = await getAuthLoader(ctx);
-        const actorObj = await flag.getActor({ documentLoader: authLoader }).catch(() => null);
-
-        const reporterUrl = actorObj?.id?.href || flag.actorId?.href || "";
-        const reporterName = actorObj?.name?.toString() || actorObj?.preferredUsername?.toString() || reporterUrl;
-
-        // Extract reported objects — Flag can report actors or posts
-        const reportedIds = flag.objectIds?.map((u) => u.href) || [];
-        const reason = flag.content?.toString() || flag.summary?.toString() || "";
-
-        if (reportedIds.length === 0 && !reason) {
-          console.info("[ActivityPub] Ignoring empty Flag from", reporterUrl);
-          return;
-        }
 
-        // Store report
-        if (collections.ap_reports) {
-          await collections.ap_reports.insertOne({
-            reporterUrl,
-            reporterName,
-            reportedUrls: reportedIds,
-            reason,
-            createdAt: new Date().toISOString(),
-            read: false,
-          });
-        }
+      await enqueueActivity(collections, {
+        activityType: "Block",
+        actorUrl: resolvedUrl || actorUrl,
+        rawJson: await block.toJsonLd(),
+      });
+    })
 
-        // Create notification
-        if (collections.ap_notifications) {
-          await addNotification(collections, {
-            uid: `flag:${reporterUrl}:${Date.now()}`,
-            type: "report",
-            actorUrl: reporterUrl,
-            actorName: reporterName,
-            actorPhoto: actorObj?.iconUrl?.href || actorObj?.icon?.url?.href || "",
-            actorHandle: actorObj?.preferredUsername
-              ? `@${actorObj.preferredUsername}@${new URL(reporterUrl).hostname}`
-              : reporterUrl,
-            objectUrl: reportedIds[0] || "",
-            summary: reason ? reason.slice(0, 200) : "Report received",
-            published: new Date().toISOString(),
-            createdAt: new Date().toISOString(),
-          });
-        }
+    // ── Add / Remove (no-ops) ───────────────────────────────────────
+    .on(Add, async () => {})
+    .on(Remove, async () => {})
 
-        await logActivity(collections, storeRawActivities, {
-          direction: "inbound",
-          type: "Flag",
-          actorUrl: reporterUrl,
-          objectUrl: reportedIds[0] || "",
-          summary: `Report from ${reporterName}: ${reason.slice(0, 100)}`,
-        });
+    // ── Flag ────────────────────────────────────────────────────────
+    .on(Flag, async (ctx, flag) => {
+      const actorUrl = flag.actorId?.href || "";
+      if (await isServerBlocked(actorUrl, collections)) return;
+      await touchKeyFreshness(collections, actorUrl);
+      await resetDeliveryStrikes(collections, actorUrl);
 
-        console.info(`[ActivityPub] Flag received from ${reporterName} — ${reportedIds.length} objects reported`);
-      } catch (error) {
-        console.warn("[ActivityPub] Flag handler error:", error.message);
-      }
+      await enqueueActivity(collections, {
+        activityType: "Flag",
+        actorUrl,
+        rawJson: await flag.toJsonLd(),
+      });
     });
 }
-
-/**
- * Log an activity to the ap_activities collection.
- * Wrapper around the shared utility that accepts the (collections, storeRaw, record) signature
- * used throughout this file.
- */
-async function logActivity(collections, storeRaw, record, rawJson) {
-  await logActivityShared(
-    collections.ap_activities,
-    record,
-    storeRaw && rawJson ? { rawJson } : {},
-  );
-}
-