@takosjp/yurucommu-core 3.4.3 → 3.4.4

package/src/backend/routes/communities/routes.ts

@@ -9,11 +9,13 @@ import {
   isNull,
   or,
   sql,
+  type SQLWrapper,
 } from "drizzle-orm";
 import {
   communities,
   communityJoinRequests,
   communityMembers,
+  follows,
   mediaUploads,
   objects,
 } from "../../../db/index.ts";
@@ -32,6 +34,7 @@ import {
 } from "./membership-shared.ts";
 import { isUniqueConstraintError } from "../../lib/parse-helpers.ts";
 import { communityRequiresMembership } from "../../lib/community-visibility.ts";
+import { operatorActorNotBlockedSql } from "../../lib/blocklist.ts";
 import { reapReplacedMediaUrl } from "../posts/delete-cascade.ts";
 
 /**
@@ -46,6 +49,32 @@ type Batchable = {
 
 const communitiesRouter = new Hono<{ Bindings: Env; Variables: Variables }>();
 
+/**
+ * Public member count = role-bearing local memberships + accepted Follow-backed
+ * memberships. `communities.memberCount` intentionally remains the local-row
+ * denormalization; federated authority already lives in `follows`, so reads
+ * compose the two sources without adding a second mutable counter lifecycle.
+ */
+function projectedCommunityMemberCountSql(
+  communityApIdVal: string | SQLWrapper,
+) {
+  return sql<number>`
+    ${communities.memberCount} + (
+      SELECT COUNT(*)
+      FROM ${follows}
+      WHERE ${follows.followingApId} = ${communityApIdVal}
+        AND ${follows.status} = 'accepted'
+        AND ${operatorActorNotBlockedSql(sql`${follows.followerApId}`)}
+        AND NOT EXISTS (
+          SELECT 1
+          FROM ${communityMembers}
+          WHERE ${communityMembers.communityApId} = ${communityApIdVal}
+            AND ${communityMembers.actorApId} = ${follows.followerApId}
+        )
+    )
+  `;
+}
+
 function isValidCommunityIconUrl(value: string): boolean {
   const trimmed = value.trim();
   if (trimmed.startsWith("/media/")) return true;
@@ -216,7 +245,7 @@ communitiesRouter.get("/", async (c) => {
       visibility: communities.visibility,
       joinPolicy: communities.joinPolicy,
       postPolicy: communities.postPolicy,
-      memberCount: communities.memberCount,
+      memberCount: projectedCommunityMemberCountSql(communities.apId),
       createdAt: communities.createdAt,
       lastMessageAt: communities.lastMessageAt,
     })
@@ -460,19 +489,25 @@ communitiesRouter.get("/:identifier", async (c) => {
   const restricted =
     communityRequiresMembership(community.visibility) && !isMember;
 
-  // member_count is the maintained `communities.memberCount` column (kept atomic
-  // by addMemberAtomic/removeMemberAtomic). post_count has no denorm column, so it
-  // is counted (indexed range via objects_comm_published_idx) — but only when the
-  // viewer is allowed to see it.
-  const postCount = restricted
-    ? 0
-    : (
-        await db
+  // `communities.memberCount` is the local-row denormalization. Compose it with
+  // accepted Follow-backed membership at read time, while preserving private
+  // community redaction. Post count similarly remains an indexed projection.
+  const [memberCountRow, postCountRow] = restricted
+    ? [{ count: 0 }, { count: 0 }]
+    : await Promise.all([
+        db
+          .select({
+            count: projectedCommunityMemberCountSql(community.apId),
+          })
+          .from(communities)
+          .where(eq(communities.apId, community.apId))
+          .get(),
+        db
           .select({ count: count() })
           .from(objects)
           .where(eq(objects.communityApId, community.apId))
-          .get()
-      )?.count || 0;
+          .get(),
+      ]);
 
   return c.json({
     community: {
@@ -484,8 +519,8 @@ communitiesRouter.get("/:identifier", async (c) => {
       visibility: community.visibility,
       join_policy: community.joinPolicy,
       post_policy: community.postPolicy,
-      member_count: restricted ? 0 : community.memberCount || 0,
-      post_count: postCount,
+      member_count: memberCountRow?.count || 0,
+      post_count: postCountRow?.count || 0,
       created_by: restricted ? null : community.createdBy,
       created_at: community.createdAt,
       is_member: isMember,

package/src/backend/routes/dm/contacts.ts

@@ -1,18 +1,7 @@
 // GET /contacts - List DM contacts and communities
 
 import { Hono } from "hono";
-import {
-  and,
-  count,
-  desc,
-  eq,
-  inArray,
-  isNotNull,
-  isNull,
-  ne,
-  or,
-  sql,
-} from "drizzle-orm";
+import { and, count, desc, eq, inArray, isNull, ne, sql } from "drizzle-orm";
 import {
   communities,
   communityMembers,
@@ -23,10 +12,15 @@ import {
 } from "../../../db/index.ts";
 import { formatUsername } from "../../federation-helpers.ts";
 import { chunkForInClause } from "../../lib/chunk.ts";
+import {
+  isActorBlockedStrict,
+  operatorActorNotBlockedSql,
+} from "../../lib/blocklist.ts";
 import { yurumeUnreadCounts } from "../../lib/unread-counts.ts";
 import {
   buildActorInfoMap,
   byTimeDesc,
+  dmWhereForActor,
   findRepliedConversations,
   formatActorProfile,
   groupConversations,
@@ -42,31 +36,10 @@ contacts.get("/contacts", async (c) => {
   if (!actor) return c.json({ error: "Unauthorized" }, 401);
   const db = c.get("db");
 
-  // DMs where this actor is the recipient are addressed via the
-  // `object_recipients` index (`recipient_ap_id = <actor>`, `type = 'to'`),
-  // written on every inbound/outbound DM whose recipient is this local actor
-  // (see dm/messages.ts, takos-tools/dm.ts, inbox-content-handlers.ts). Using
-  // that index instead of an unindexable `to_json LIKE '%"<apId>"%'` substring
-  // scan keeps the same membership semantics (recipient OR author) without a
-  // full-table scan.
-  const recipientObjectIds = db
-    .select({ objectApId: objectRecipients.objectApId })
-    .from(objectRecipients)
-    .where(
-      and(
-        eq(objectRecipients.recipientApId, actor.ap_id),
-        eq(objectRecipients.type, "to"),
-      ),
-    );
-  const dmWhere = and(
-    eq(objects.visibility, "direct"),
-    eq(objects.type, "Note"),
-    isNotNull(objects.conversation),
-    or(
-      eq(objects.attributedTo, actor.ap_id),
-      inArray(objects.apId, recipientObjectIds),
-    ),
-  );
+  // Shared indexed DM membership + operator-block predicate. Keeping the
+  // counterpart decision in one helper makes contacts, archived threads, and
+  // Takos tool threads agree for both incoming and outgoing messages.
+  const dmWhere = dmWhereForActor(db, actor.ap_id);
 
   // GET must be side-effect-free: this handler no longer prunes orphaned
   // dm_read_status rows. Read-status cleanup happens on the write paths that
@@ -154,6 +127,7 @@ contacts.get("/contacts", async (c) => {
                 eq(objects.visibility, "direct"),
                 ne(objects.attributedTo, actor.ap_id),
                 sql`${objects.published} > ${lastReadAt}`,
+                operatorActorNotBlockedSql(sql`${objects.attributedTo}`),
               ),
             )
             .groupBy(objects.conversation);
@@ -205,7 +179,12 @@ contacts.get("/contacts", async (c) => {
       communities,
       eq(communityMembers.communityApId, communities.apId),
     )
-    .where(eq(communityMembers.actorApId, actor.ap_id));
+    .where(
+      and(
+        eq(communityMembers.actorApId, actor.ap_id),
+        isNull(communities.deletedAt),
+      ),
+    );
 
   // Batch get the last CHAT message for all communities to avoid N+1.
   //
@@ -250,6 +229,7 @@ contacts.get("/contacts", async (c) => {
           eq(objectRecipients.type, "audience"),
           eq(objects.type, "Note"),
           isNull(objects.communityApId),
+          operatorActorNotBlockedSql(sql`${objects.attributedTo}`),
         ),
       )
       .orderBy(desc(objects.published))
@@ -301,6 +281,7 @@ contacts.get("/contacts", async (c) => {
         ON r.community_ap_id = cm.community_ap_id
         AND r.actor_ap_id = ${me}
       WHERE cm.actor_ap_id = ${me}
+        AND ${operatorActorNotBlockedSql(sql.raw("o.attributed_to"))}
         AND o.published > COALESCE(r.last_read_at, cm.joined_at, '1970-01-01T00:00:00Z')
       GROUP BY cm.community_ap_id
     `);
@@ -315,7 +296,10 @@ contacts.get("/contacts", async (c) => {
       return {
         type: "community" as const,
         ap_id: cm.community.apId,
-        username: formatUsername(cm.community.apId),
+        username: formatUsername(
+          cm.community.apId,
+          cm.community.preferredUsername,
+        ),
         preferred_username: cm.community.preferredUsername,
         name: cm.community.name,
         icon_url: cm.community.iconUrl,
@@ -356,6 +340,7 @@ contacts.get("/contacts", async (c) => {
         eq(objects.type, "Note"),
         eq(objectRecipients.recipientApId, actor.ap_id),
         eq(objectRecipients.type, "to"),
+        operatorActorNotBlockedSql(sql`${objects.attributedTo}`),
       ),
     );
 
@@ -402,7 +387,7 @@ contacts.get("/contact/:encodedApId", async (c) => {
       visibility: communities.visibility,
     })
     .from(communities)
-    .where(eq(communities.apId, apId))
+    .where(and(eq(communities.apId, apId), isNull(communities.deletedAt)))
     .get();
 
   if (community) {
@@ -427,7 +412,7 @@ contacts.get("/contact/:encodedApId", async (c) => {
       contact: {
         type: "community" as const,
         ap_id: community.apId,
-        username: formatUsername(community.apId),
+        username: formatUsername(community.apId, community.preferredUsername),
         preferred_username: community.preferredUsername,
         name: community.name,
         icon_url: community.iconUrl,
@@ -440,6 +425,9 @@ contacts.get("/contact/:encodedApId", async (c) => {
   }
 
   // Otherwise treat it as a user (local actor or cached remote actor).
+  if (await isActorBlockedStrict(db, apId)) {
+    return c.json({ error: "Contact not found" }, 404);
+  }
   const infoMap = await buildActorInfoMap(db, [apId]);
   const info = infoMap.get(apId);
   if (!info) return c.json({ error: "Contact not found" }, 404);

package/src/backend/routes/dm/conversations-helpers.ts

@@ -1,12 +1,13 @@
 // Shared helpers for DM conversations
 
 import type { Context } from "hono";
-import { and, eq, inArray, isNotNull, or } from "drizzle-orm";
+import { and, eq, inArray, isNotNull, or, sql } from "drizzle-orm";
 import type { Database } from "../../../db/index.ts";
 import { objectRecipients, objects } from "../../../db/index.ts";
 import type { Env, Variables } from "../../types.ts";
 import { safeJsonParse } from "../../federation-helpers.ts";
 import { chunkForInClause } from "../../lib/chunk.ts";
+import { operatorActorNotBlockedSql } from "../../lib/blocklist.ts";
 
 /**
  * Indexed lookup of the object AP-IDs a given actor was addressed on as a DM
@@ -75,6 +76,13 @@ export function dmWhereForActor(db: Database, actorApId: string) {
       eq(objects.attributedTo, actorApId),
       inArray(objects.apId, recipientObjectIds(db, actorApId)),
     ),
+    operatorActorNotBlockedSql(sql`
+      CASE
+        WHEN ${objects.attributedTo} = ${actorApId}
+          THEN json_extract(${objects.toJson}, '$[0]')
+        ELSE ${objects.attributedTo}
+      END
+    `),
   );
 }
 

package/src/backend/routes/dm/messages.ts

@@ -3,7 +3,7 @@
 // Threading via conversation field
 
 import { Hono } from "hono";
-import { and, desc, eq, inArray, like } from "drizzle-orm";
+import { and, desc, eq, inArray, like, or } from "drizzle-orm";
 import type { Database } from "../../../db/index.ts";
 import {
   activities,
@@ -34,6 +34,7 @@ import {
   MAX_DM_PAGE_LIMIT,
   resolveConversationId,
 } from "./query-helpers.ts";
+import { recipientObjectIds } from "./conversations-helpers.ts";
 import { enqueueDeliveryToActor } from "../../lib/delivery/queue.ts";
 import {
   emitRealtimeBestEffort,
@@ -43,6 +44,8 @@ import { feedCursorWhere } from "../../lib/feed-cursor.ts";
 import { toApAttachments } from "../../lib/activitypub-helpers.ts";
 import { validateChatAttachments } from "../../lib/attachments.ts";
 import { logger } from "../../lib/logger.ts";
+import { isActorBlockedStrict } from "../../lib/blocklist.ts";
+import { deleteActivitiesCascade } from "../../lib/activity-delete-cascade.ts";
 
 const log = logger.child({ component: "dm.messages" });
 
@@ -81,12 +84,7 @@ type SenderInfo = {
 // on the 4s-polled endpoint).
 type DmMessageRow = Pick<
   typeof objects.$inferSelect,
-  | "apId"
-  | "attributedTo"
-  | "content"
-  | "attachmentsJson"
-  | "published"
-  | "toJson"
+  "apId" | "attributedTo" | "content" | "attachmentsJson" | "published"
 >;
 
 type DmMessageResponse = {
@@ -156,7 +154,7 @@ function buildSenderFromActor(actor: {
 }): SenderInfo {
   return {
     ap_id: actor.ap_id,
-    username: formatUsername(actor.ap_id),
+    username: formatUsername(actor.ap_id, actor.preferred_username),
     preferred_username: actor.preferred_username,
     name: actor.name,
     icon_url: actor.icon_url,
@@ -177,12 +175,19 @@ async function fetchAuthorizedMessages(
   limit: number,
   before: string | undefined,
 ): Promise<{ rows: DmMessageRow[]; hasMore: boolean }> {
-  // Build where clause: filter by conversation + visibility + type
-  // Authorization is re-validated in code below (defense-in-depth)
+  // Authorization is part of the SQL set, not a post-query to_json filter.
+  // Hidden bto/bcc recipients intentionally do not appear in to_json; their
+  // indexed object_recipients link is the read authority used everywhere else
+  // in the DM subsystem. Keeping the predicate inside the query also makes the
+  // limit+1 pagination signal exact after authorization.
   const baseCondition = and(
     eq(objects.visibility, "direct"),
     eq(objects.type, "Note"),
     eq(objects.conversation, conversationId),
+    or(
+      eq(objects.attributedTo, actorApId),
+      inArray(objects.apId, recipientObjectIds(db, actorApId)),
+    ),
   );
 
   // Composite (published, apId) cursor so two messages sharing a published
@@ -203,24 +208,14 @@ async function fetchAuthorizedMessages(
       content: objects.content,
       attachmentsJson: objects.attachmentsJson,
       published: objects.published,
-      toJson: objects.toJson,
     })
     .from(objects)
     .where(whereClause!)
     .orderBy(desc(objects.published), desc(objects.apId))
     .limit(limit + 1);
 
-  // Defence-in-depth: re-validate authorization at the code level. (In practice
-  // every row in the actor's own conversation passes, so the +1 reliably signals
-  // an older page.)
-  const authorized = messages.filter((msg) => {
-    if (msg.attributedTo === actorApId) return true;
-    const toRecipients = safeJsonParse<string[]>(msg.toJson, []);
-    return toRecipients.includes(actorApId);
-  });
-
-  const hasMore = authorized.length > limit;
-  return { rows: hasMore ? authorized.slice(0, limit) : authorized, hasMore };
+  const hasMore = messages.length > limit;
+  return { rows: hasMore ? messages.slice(0, limit) : messages, hasMore };
 }
 
 /** Build a map from ap_id -> actor info, checking local actors then cached actors. */
@@ -273,7 +268,7 @@ function formatMessages(
       id: msg.apId,
       sender: {
         ap_id: msg.attributedTo,
-        username: formatUsername(msg.attributedTo),
+        username: formatUsername(msg.attributedTo, info?.preferredUsername),
         preferred_username: info?.preferredUsername || null,
         name: info?.name || null,
         icon_url: info?.iconUrl || null,
@@ -379,6 +374,9 @@ dm.get("/user/:encodedApId/messages", async (c) => {
 
   const db = c.get("db");
   const otherApId = decodeURIComponent(c.req.param("encodedApId"));
+  if (await isActorBlockedStrict(db, otherApId)) {
+    return c.json({ error: "User not found" }, 404);
+  }
   const limit = parseLimit(c.req.query("limit"), 50, MAX_DM_PAGE_LIMIT);
   const before = c.req.query("before");
   // Resolve to the STORED conversation id of an existing thread rather than
@@ -429,6 +427,13 @@ dm.post("/user/:encodedApId/messages", async (c) => {
 
   const db = c.get("db");
   const otherApId = decodeURIComponent(c.req.param("encodedApId"));
+  // Operator defederation is an authority boundary, not merely a late queue
+  // filter. Reject before recipient lookup, body work, conversation resolution,
+  // or any Note/Activity write so the API cannot claim a DM was sent when its
+  // delivery is guaranteed to be skipped.
+  if (await isActorBlockedStrict(db, otherApId)) {
+    return c.json({ error: "User not found" }, 404);
+  }
   const body = await c.req.json<{
     content?: string;
     attachments?: unknown;
@@ -708,25 +713,14 @@ dm.delete("/messages/:messageId", async (c) => {
   }
   const message = messageOrError;
 
-  // Sequential operations (D1 doesn't support interactive transactions).
-  // Also remove the delivery Create activity + the recipient's inbox row created
-  // at send time (messages.ts send path). These tables are addressed by AP id
-  // with no FK to `objects`, so deleting only the object orphans them — and
-  // because the notifications query LEFT JOINs the now-missing object (a
-  // deleted DM's object is gone → NULL visibility → not excluded as "direct"),
-  // the orphan Create inbox row would resurface as a blank "mention"
-  // notification with a dead /post link. Drop them first.
-  const relatedActivities = await db
-    .select({ apId: activities.apId })
-    .from(activities)
-    .where(eq(activities.objectApId, message.apId));
-  const activityIds = relatedActivities.map((a) => a.apId);
-  if (activityIds.length > 0) {
-    await db
-      .delete(inboxTable)
-      .where(inArray(inboxTable.activityApId, activityIds));
-    await db.delete(activities).where(inArray(activities.apId, activityIds));
-  }
+  // Sequential object/media operations (D1 doesn't support interactive
+  // transactions). First atomically remove every delivery Create activity and
+  // its activity-keyed inbox/push/delivery/archive/claim projections. These
+  // tables are addressed by AP id with no object FK, so deleting only the object
+  // orphans them — and because the notifications query LEFT JOINs the now-missing
+  // object (NULL visibility → not excluded as "direct"), an orphan inbox row
+  // resurfaces as a blank "mention" with a dead /post link.
+  await deleteActivitiesCascade(db, eq(activities.objectApId, message.apId));
   // Reap the message's child rows AND any attached R2 blob + media_uploads row
   // via the shared cascade (covers objectRecipients + media + likes/announces/
   // bookmarks/story*), then drop the object. Local DMs are text-only today so

package/src/backend/routes/dm/read-archive.ts

@@ -1,7 +1,7 @@
 // DM read status and archive management
 
 import { Hono } from "hono";
-import { and, desc, eq } from "drizzle-orm";
+import { and, desc, eq, isNull } from "drizzle-orm";
 import {
   communities,
   communityMembers,
@@ -95,7 +95,9 @@ readArchive.post("/community/:encodedApId/read", async (c) => {
   const community = await db
     .select({ apId: communities.apId })
     .from(communities)
-    .where(eq(communities.apId, communityApId))
+    .where(
+      and(eq(communities.apId, communityApId), isNull(communities.deletedAt)),
+    )
     .get();
   if (!community) return c.json({ error: "Community not found" }, 404);
 

package/src/backend/routes/dm/requests.ts

@@ -1,14 +1,8 @@
 // DM requests - list, accept, reject
 
 import { Hono } from "hono";
-import { and, desc, eq, inArray, isNotNull, sql } from "drizzle-orm";
-import {
-  activities,
-  blocks,
-  inbox as inboxTable,
-  objectRecipients,
-  objects,
-} from "../../../db/index.ts";
+import { and, asc, desc, eq, gt, inArray, isNotNull, sql } from "drizzle-orm";
+import { activities, blocks, objects } from "../../../db/index.ts";
 import { resolveConversationId } from "./query-helpers.ts";
 import {
   buildActorInfoMap,
@@ -17,6 +11,13 @@ import {
   type HonoEnv,
   recipientObjectIds,
 } from "./conversations-helpers.ts";
+import { operatorActorNotBlockedSql } from "../../lib/blocklist.ts";
+import { deleteActivitiesCascade } from "../../lib/activity-delete-cascade.ts";
+import { D1_IN_CHUNK } from "../../lib/chunk.ts";
+import {
+  deleteObjectsCascade,
+  purgeMediaBlobs,
+} from "../posts/delete-cascade.ts";
 
 // Upper bound on the number of pending-request CONVERSATIONS returned. The list
 // is collapsed to one row per conversation in SQL (GROUP BY), so this bounds
@@ -58,6 +59,7 @@ requests.get("/requests", async (c) => {
         // instead of an unindexable `to_json LIKE '%"<apId>"%'` scan; same
         // recipient-membership semantics.
         inArray(objects.apId, recipientObjectIds(db, actor.ap_id)),
+        operatorActorNotBlockedSql(sql`${objects.attributedTo}`),
       ),
     )
     .groupBy(objects.conversation)
@@ -121,56 +123,62 @@ requests.post("/requests/reject", async (c) => {
     body.sender_ap_id,
   );
 
-  // The set of the sender's messages in this conversation, as a reusable
-  // SUBQUERY (never materialised into an `IN (...)`, which would blow D1's
-  // 100-bound-parameter ceiling once a spammer has written >~100 messages).
+  // One exact owner predicate for every cleanup stage. A legacy/corrupt public
+  // row can share the conversation string; omitting the direct-Note scope from
+  // only the Activity/recipient subqueries would delete that survivor's
+  // projections while leaving its object behind.
+  const senderMessageWhere = (afterApId?: string) =>
+    and(
+      eq(objects.conversation, conversationId),
+      eq(objects.visibility, "direct"),
+      eq(objects.type, "Note"),
+      eq(objects.attributedTo, body.sender_ap_id),
+      afterApId ? gt(objects.apId, afterApId) : undefined,
+    );
+
+  // The complete sender message set stays a subquery here (never materialised
+  // into one unbounded `IN (...)`) so Activity hard deletion remains one
+  // constant-parameter atomic unit even after a spammer writes >100 messages.
   const senderObjectIds = db
     .select({ apId: objects.apId })
     .from(objects)
-    .where(
-      and(
-        eq(objects.conversation, conversationId),
-        eq(objects.attributedTo, body.sender_ap_id),
-      ),
-    );
+    .where(senderMessageWhere());
+
+  // Drop every delivery Create activity and its durable projections FIRST,
+  // before the objects vanish. These tables are addressed by AP id with no FK
+  // to `objects`, so deleting only the object orphans them — and the
+  // notifications query LEFT JOINs the now-missing object (gone → NULL
+  // visibility → no longer excluded as "direct"), so each orphan Create would
+  // resurface as a blank "mention" with a dead link plus an inflated unread
+  // badge while push/delivery workers churn. This mirrors DM message deletion.
+  await deleteActivitiesCascade(
+    db,
+    inArray(activities.objectApId, senderObjectIds),
+  );
 
-  // Drop the inbox + delivery Create activities for those messages FIRST, before
-  // the objects vanish. These tables are addressed by AP id with no FK to
-  // `objects`, so deleting only the object orphans them — and the notifications
-  // query LEFT JOINs the now-missing object (gone → NULL visibility → no longer
-  // excluded as "direct"), so each orphan Create would resurface as a blank
-  // "mention" notification with a dead link plus an inflated unread badge. This
-  // mirrors the DM message-delete cleanup (messages.ts).
-  await db
-    .delete(inboxTable)
-    .where(
-      inArray(
-        inboxTable.activityApId,
-        db
-          .select({ apId: activities.apId })
-          .from(activities)
-          .where(inArray(activities.objectApId, senderObjectIds)),
-      ),
-    );
-  await db
-    .delete(activities)
-    .where(inArray(activities.objectApId, senderObjectIds));
-
-  // Delete the recipient rows for every message the sender wrote in this
-  // conversation (same subquery-not-IN reasoning as above).
-  await db
-    .delete(objectRecipients)
-    .where(inArray(objectRecipients.objectApId, senderObjectIds));
-
-  await db
-    .delete(objects)
-    .where(
-      and(
-        eq(objects.conversation, conversationId),
-        eq(objects.visibility, "direct"),
-        eq(objects.attributedTo, body.sender_ap_id),
-      ),
-    );
+  // Drain object ids in D1-safe keyset pages. Each page routes through the same
+  // semantic child + durable projection + media owner as single-message
+  // deletion, then drops the objects and finally performs the irreversible R2
+  // purge. This avoids both an unbounded parameter list and loading a spammer's
+  // complete private history into isolate memory.
+  let cursor: string | undefined;
+  while (true) {
+    const page = await db
+      .select({ apId: objects.apId })
+      .from(objects)
+      .where(senderMessageWhere(cursor))
+      .orderBy(asc(objects.apId))
+      .limit(D1_IN_CHUNK);
+    if (page.length === 0) break;
+
+    const apIds = page.map((row) => row.apId);
+    const mediaKeys = await deleteObjectsCascade(db, apIds, c.env.MEDIA);
+    await db.delete(objects).where(inArray(objects.apId, apIds));
+    await purgeMediaBlobs(c.env.MEDIA, mediaKeys);
+
+    cursor = apIds.at(-1);
+    if (!cursor || page.length < D1_IN_CHUNK) break;
+  }
 
   if (body.block) {
     await db