@takosjp/yurucommu-core 3.4.3 → 3.4.4

package/src/backend/lib/delivery/queue-batching.ts

@@ -14,13 +14,17 @@ import {
   deliveryQueue,
   follows,
   inbox as inboxTable,
+  insertMany,
+  runBatch,
+  type D1Statement,
 } from "../../../db/index.ts";
 import { isLocal, isSafeRemoteUrl } from "../../federation-helpers.ts";
-import { isActorBlocked } from "../blocklist.ts";
+import { isActorBlockedStrict } from "../blocklist.ts";
 import { planEndpointsFromActorCache } from "./planner.ts";
 import {
   fetchAndUpsertActorCache,
   getInstanceFetchSignerByDb,
+  isRemoteActorTombstoned,
 } from "../activitypub-actor-cache.ts";
 import {
   DELIVERY_QUEUE_MESSAGE_VERSION,
@@ -38,6 +42,7 @@ import {
 import {
   buildDeliverEndpointMessage,
   buildResolveActorMessage,
+  enqueuePendingDeliveryEndpointJobs,
   MAX_RECONCILE_ATTEMPTS,
   nowIso,
   type QueueEnv,
@@ -46,13 +51,23 @@ import {
   upsertDeliveryJob,
 } from "./queue.ts";
 import { logger } from "../logger.ts";
+import {
+  claimDeliveryResolutionJob,
+  completeDeliveryResolutionJob,
+  deferDeliveryResolutionJob,
+  enqueueDeliveryResolutionJobs,
+  enqueuePendingDeliveryResolutionJobs,
+  MAX_RESOLVE_ATTEMPTS,
+  retryDeliveryResolutionJob,
+} from "./resolution-outbox.ts";
+import {
+  completeDeliveryFanoutJob,
+  deliveryFanoutIntentFromMessage,
+  getDeliveryFanoutState,
+  resetDeliveryFanoutJob,
+} from "./fanout-outbox.ts";
 
 const DELIVERY_HTTP_TIMEOUT_MS = 8000;
-// Cap on resolve_actor self-requeues (each ~60s apart) before giving up on a
-// permanently-unresolvable recipient — otherwise a dead host churns one queue
-// message every 60s forever.
-const MAX_RESOLVE_ATTEMPTS = 8;
-
 const log = logger.child({ component: "delivery.batching" });
 
 async function fetchAndCacheRemoteActor(
@@ -113,7 +128,7 @@ async function sendQueueBatchChunked(
  */
 export async function enqueueFollowerEndpointDeliveries(
   db: Database,
-  queue: QueueEnv["DELIVERY_QUEUE"],
+  queue: QueueEnv["DELIVERY_QUEUE"] | undefined,
   baseUrl: string,
   activityId: string,
   followeeApId: string,
@@ -168,16 +183,41 @@ export async function enqueueFollowerEndpointDeliveries(
       const deliverRequests: Array<{ body: DeliveryQueueMessageV1 }> = [];
       for (const group of planned.groups) {
         const jobId = await computeDeliveryJobId(activityId, group.endpoint);
-        await upsertDeliveryJob(db, jobId, activityId, group.endpoint);
-        deliverRequests.push({ body: buildDeliverEndpointMessage(jobId) });
+        const active = await upsertDeliveryJob(
+          db,
+          jobId,
+          activityId,
+          group.endpoint,
+          group.recipientActorApIds,
+        );
+        if (active) {
+          deliverRequests.push({ body: buildDeliverEndpointMessage(jobId) });
+        }
       }
 
-      const resolveRequests = planned.unknownRecipients.map((apId) => ({
-        body: buildResolveActorMessage(activityId, apId),
-      }));
+      // Persist every durable first-hop row before the first Queue RPC. Queue
+      // messages are only wakeups; losing or lacking the producer must never
+      // erase the delivery authority for an irreversible account teardown.
+      await enqueueDeliveryResolutionJobs(
+        db,
+        undefined,
+        planned.unknownRecipients.map((recipientActorApId) => ({
+          activityId,
+          recipientActorApId,
+        })),
+      );
 
-      await sendQueueBatchChunked(queue, deliverRequests);
-      await sendQueueBatchChunked(queue, resolveRequests);
+      if (queue) {
+        await sendQueueBatchChunked(queue, deliverRequests);
+        await enqueueDeliveryResolutionJobs(
+          db,
+          queue,
+          planned.unknownRecipients.map((recipientActorApId) => ({
+            activityId,
+            recipientActorApId,
+          })),
+        );
+      }
     }
 
     processed += page.length;
@@ -199,10 +239,10 @@ export async function enqueueFollowerEndpointDeliveries(
  * `fanout_followers` consumer would otherwise run after the follower graph is
  * gone and reach zero remote followers.
  *
- * Best-effort and queue-aware: if the delivery queue bindings are missing it
- * is a no-op (mirrors enqueueFanoutToFollowers' silent producer-unavailable
- * behavior). Never throws into the caller's teardown transaction — the caller
- * still wraps it so federation can never block local deletion.
+ * Persistence does not depend on Queue bindings: Queue messages are wakeups,
+ * while delivery_queue / delivery_resolutions remain the retry authority after
+ * the follower graph is erased. The full graph is snapshotted before any
+ * producer RPC, so a producer outage cannot leave only the first page durable.
  */
 export async function snapshotAndEnqueueFollowerDeliveries(
   db: Database,
@@ -210,14 +250,20 @@ export async function snapshotAndEnqueueFollowerDeliveries(
   activityId: string,
   followeeApId: string,
 ): Promise<void> {
-  const queue = (env as Partial<QueueEnv>).DELIVERY_QUEUE;
+  const queueEnv = env as Partial<QueueEnv>;
+  const queue =
+    queueEnv.DELIVERY_QUEUE && queueEnv.DELIVERY_DLQ
+      ? queueEnv.DELIVERY_QUEUE
+      : undefined;
   if (!queue) {
-    log.warn("Delivery queue unavailable; follower snapshot delivery skipped", {
-      event: "delivery.fanout.snapshot_queue_unavailable",
-      followee: followeeApId,
-      activityId,
-    });
-    return;
+    log.warn(
+      "Delivery queue unavailable; follower snapshot persisted without wakeups",
+      {
+        event: "delivery.fanout.snapshot_queue_unavailable",
+        followee: followeeApId,
+        activityId,
+      },
+    );
   }
 
   let cursor: string | null = null;
@@ -225,7 +271,7 @@ export async function snapshotAndEnqueueFollowerDeliveries(
   do {
     const page = await enqueueFollowerEndpointDeliveries(
       db,
-      queue,
+      undefined,
       env.APP_URL,
       activityId,
       followeeApId,
@@ -243,6 +289,25 @@ export async function snapshotAndEnqueueFollowerDeliveries(
       processed,
     });
   }
+
+  if (queue) {
+    // Publish only after every follower page is durable. These bounded sweeps
+    // wake the first tranche immediately; request/queue/cron recovery drains
+    // any remaining rows from the same outboxes.
+    try {
+      await enqueuePendingDeliveryEndpointJobs(env, new Date(), {
+        includeFreshPending: true,
+      });
+      await enqueuePendingDeliveryResolutionJobs(env);
+    } catch (error) {
+      log.error("Follower snapshot persisted but Queue wakeup failed", {
+        event: "delivery.fanout.snapshot_wakeup_failed",
+        followee: followeeApId,
+        activityId,
+        error,
+      });
+    }
+  }
 }
 
 export async function processFanoutFollowers(
@@ -251,7 +316,31 @@ export async function processFanoutFollowers(
   msg: DeliveryFanoutFollowersMessageV1,
   message: IQueueMessage<DeliveryQueueMessageV1>,
 ): Promise<void> {
-  if (!requireQueue(env, "fanout", message)) return;
+  const intent = deliveryFanoutIntentFromMessage(msg);
+  const outboxState = await getDeliveryFanoutState(db, intent);
+  if (outboxState === "terminal") {
+    message.ack();
+    return;
+  }
+  const activityExists = await db
+    .select({ apId: activities.apId })
+    .from(activities)
+    .where(eq(activities.apId, msg.activityId))
+    .get();
+  if (!activityExists) {
+    await completeDeliveryFanoutJob(
+      db,
+      intent,
+      "discarded",
+      "Activity was deleted before fanout completed",
+    );
+    message.ack();
+    return;
+  }
+  if (!requireQueue(env, "fanout", message)) {
+    await resetDeliveryFanoutJob(db, intent, "Queue bindings unavailable");
+    return;
+  }
   const queueEnv = env as QueueEnv;
 
   const { processed, capped, nextCursor } =
@@ -284,6 +373,10 @@ export async function processFanoutFollowers(
     });
   }
 
+  if (!capped) {
+    await completeDeliveryFanoutJob(db, intent);
+  }
+
   message.ack();
 }
 
@@ -309,24 +402,60 @@ export async function processFanoutCommunity(
 ): Promise<void> {
   const baseUrl = env.APP_URL;
 
-  if (!requireQueue(env, "fanout_community", message)) return;
-  const queueEnv = env as QueueEnv;
+  const intent = deliveryFanoutIntentFromMessage(msg);
+  const outboxState = await getDeliveryFanoutState(db, intent);
+  if (outboxState === "terminal") {
+    message.ack();
+    return;
+  }
 
-  // Resolve the activity's author so we never echo the post back into the
-  // author's own inbox.
-  const activityRow = await db
-    .select({ actorApId: activities.actorApId })
+  const activityExists = await db
+    .select({ apId: activities.apId, actorApId: activities.actorApId })
     .from(activities)
     .where(eq(activities.apId, msg.activityId))
     .get();
-  const authorApId = activityRow?.actorApId ?? null;
+  if (!activityExists) {
+    await completeDeliveryFanoutJob(
+      db,
+      intent,
+      "discarded",
+      "Activity was deleted before fanout completed",
+    );
+    message.ack();
+    return;
+  }
 
-  // ----- 1. Local members: deliver to their inbox directly. ----------------
-  let memberCursor: string | null = null;
-  while (true) {
+  if (!requireQueue(env, "fanout_community", message)) {
+    await resetDeliveryFanoutJob(db, intent, "Queue bindings unavailable");
+    return;
+  }
+  const queueEnv = env as QueueEnv;
+
+  const authorApId = activityExists.actorApId;
+  const stage = msg.stage ?? "local_members";
+  const cursor = msg.cursor ?? null;
+  const enqueueContinuation = async (
+    nextStage: NonNullable<DeliveryFanoutCommunityMessageV1["stage"]>,
+    nextCursor: string | null,
+  ) => {
+    await sendQueueMessage(env, {
+      version: DELIVERY_QUEUE_MESSAGE_VERSION,
+      type: "fanout_community",
+      activityId: msg.activityId,
+      communityApId: msg.communityApId,
+      ...(msg.announceActivityId
+        ? { announceActivityId: msg.announceActivityId }
+        : {}),
+      stage: nextStage,
+      ...(nextCursor ? { cursor: nextCursor } : {}),
+      scheduledAt: nowIso(),
+    });
+  };
+
+  if (stage === "local_members") {
     const conditions = [eq(communityMembers.communityApId, msg.communityApId)];
-    if (memberCursor !== null) {
-      conditions.push(sql`${communityMembers.actorApId} > ${memberCursor}`);
+    if (cursor !== null) {
+      conditions.push(sql`${communityMembers.actorApId} > ${cursor}`);
     }
     const page = await db
       .select({ actorApId: communityMembers.actorApId })
@@ -334,138 +463,120 @@ export async function processFanoutCommunity(
       .where(and(...conditions))
       .orderBy(communityMembers.actorApId)
       .limit(FANOUT_FOLLOWER_PAGE_SIZE);
-
-    if (page.length === 0) break;
-    memberCursor = page[page.length - 1].actorApId;
-
     const localRecipients = page
-      .map((m) => m.actorApId)
+      .map((row) => row.actorApId)
       .filter((apId) => isLocal(apId, baseUrl) && apId !== authorApId);
-
     if (localRecipients.length > 0) {
       const now = nowIso();
-      await db
-        .insert(inboxTable)
-        .values(
-          localRecipients.map((actorApId) => ({
-            actorApId,
-            activityApId: msg.activityId,
-            read: 0,
-            createdAt: now,
-          })),
-        )
-        .onConflictDoNothing();
-    }
-
-    if (page.length < FANOUT_FOLLOWER_PAGE_SIZE) break;
-  }
-
-  // ----- 2. Remote recipients: plan endpoints and deliver. -----------------
-  // Remote members of the community plus accepted followers of the community
-  // actor. A community member set is typically modest; followers of the
-  // community actor capture remote servers that follow the Group to receive
-  // its activities. Both are deduped before planning.
-  const remoteRecipients = new Set<string>();
-
-  // Remote community members.
-  {
-    let cursor: string | null = null;
-    let processed = 0;
-    while (processed < FANOUT_MAX_FOLLOWERS) {
-      const conditions = [
-        eq(communityMembers.communityApId, msg.communityApId),
-      ];
-      if (cursor !== null) {
-        conditions.push(sql`${communityMembers.actorApId} > ${cursor}`);
-      }
-      const page = await db
-        .select({ actorApId: communityMembers.actorApId })
-        .from(communityMembers)
-        .where(and(...conditions))
-        .orderBy(communityMembers.actorApId)
-        .limit(FANOUT_FOLLOWER_PAGE_SIZE);
-      if (page.length === 0) break;
-      cursor = page[page.length - 1].actorApId;
-      for (const m of page) {
-        if (!isLocal(m.actorApId, baseUrl) && m.actorApId !== authorApId) {
-          remoteRecipients.add(m.actorApId);
-        }
+      const statements = insertMany(
+        db,
+        inboxTable,
+        localRecipients.map((actorApId) => ({
+          actorApId,
+          activityApId: msg.activityId,
+          read: 0,
+          createdAt: now,
+        })),
+        { conflict: "ignore" },
+      );
+      if (statements.length > 0) {
+        await runBatch(db, statements as [D1Statement, ...D1Statement[]]);
       }
-      processed += page.length;
-      if (page.length < FANOUT_FOLLOWER_PAGE_SIZE) break;
     }
+    if (page.length === FANOUT_FOLLOWER_PAGE_SIZE) {
+      await enqueueContinuation(
+        "local_members",
+        page[page.length - 1].actorApId,
+      );
+    } else {
+      await enqueueContinuation("remote_members", null);
+    }
+    message.ack();
+    return;
   }
 
-  // Accepted followers of the community actor.
-  {
-    let cursor: string | null = null;
-    let processed = 0;
-    while (processed < FANOUT_MAX_FOLLOWERS) {
-      const conditions = [
-        eq(follows.followingApId, msg.communityApId),
-        eq(follows.status, "accepted"),
-      ];
-      if (cursor !== null) {
-        conditions.push(sql`${follows.followerApId} > ${cursor}`);
-      }
-      const page = await db
-        .select({ followerApId: follows.followerApId })
-        .from(follows)
-        .where(and(...conditions))
-        .orderBy(follows.followerApId)
-        .limit(FANOUT_FOLLOWER_PAGE_SIZE);
-      if (page.length === 0) break;
-      cursor = page[page.length - 1].followerApId;
-      for (const f of page) {
-        if (
-          !isLocal(f.followerApId, baseUrl) &&
-          f.followerApId !== authorApId
-        ) {
-          remoteRecipients.add(f.followerApId);
-        }
-      }
-      processed += page.length;
-      if (page.length < FANOUT_FOLLOWER_PAGE_SIZE) break;
+  let pageActorApIds: string[];
+  if (stage === "remote_members") {
+    const conditions = [eq(communityMembers.communityApId, msg.communityApId)];
+    if (cursor !== null) {
+      conditions.push(sql`${communityMembers.actorApId} > ${cursor}`);
     }
+    const page = await db
+      .select({ actorApId: communityMembers.actorApId })
+      .from(communityMembers)
+      .where(and(...conditions))
+      .orderBy(communityMembers.actorApId)
+      .limit(FANOUT_FOLLOWER_PAGE_SIZE);
+    pageActorApIds = page.map((row) => row.actorApId);
+  } else {
+    const conditions = [
+      eq(follows.followingApId, msg.communityApId),
+      eq(follows.status, "accepted"),
+    ];
+    if (cursor !== null) {
+      conditions.push(sql`${follows.followerApId} > ${cursor}`);
+    }
+    const page = await db
+      .select({ actorApId: follows.followerApId })
+      .from(follows)
+      .where(and(...conditions))
+      .orderBy(follows.followerApId)
+      .limit(FANOUT_FOLLOWER_PAGE_SIZE);
+    pageActorApIds = page.map((row) => row.actorApId);
   }
 
-  const remoteList = [...remoteRecipients];
-  if (remoteList.length > 0) {
-    // Announce-relay: remote followers receive the GROUP's Announce of the post
-    // (when present) rather than the raw author activity, so it is attributed
-    // to the community. Local members above kept the raw `activityId`.
+  const remoteRecipients = [...new Set(pageActorApIds)].filter(
+    (apId) => !isLocal(apId, baseUrl) && apId !== authorApId,
+  );
+  if (remoteRecipients.length > 0) {
+    // Announce-relay: remote recipients receive the Group's Announce (when
+    // present); local members above retain the raw author Activity.
     const remoteActivityId = msg.announceActivityId ?? msg.activityId;
-    const planned = await planEndpointsFromActorCache(db, remoteList, {
+    const planned = await planEndpointsFromActorCache(db, remoteRecipients, {
       metricTags: {
         community: msg.communityApId,
         activity: remoteActivityId,
       },
     });
-
     const deliverRequests: Array<{ body: DeliveryQueueMessageV1 }> = [];
     for (const group of planned.groups) {
       const jobId = await computeDeliveryJobId(
         remoteActivityId,
         group.endpoint,
       );
-      await upsertDeliveryJob(db, jobId, remoteActivityId, group.endpoint);
-      deliverRequests.push({ body: buildDeliverEndpointMessage(jobId) });
+      const active = await upsertDeliveryJob(
+        db,
+        jobId,
+        remoteActivityId,
+        group.endpoint,
+        group.recipientActorApIds,
+      );
+      if (active) {
+        deliverRequests.push({ body: buildDeliverEndpointMessage(jobId) });
+      }
     }
-
-    const resolveRequests = planned.unknownRecipients.map((apId) => ({
-      body: buildResolveActorMessage(remoteActivityId, apId),
-    }));
-
     await sendQueueBatchChunked(queueEnv.DELIVERY_QUEUE, deliverRequests);
-    await sendQueueBatchChunked(queueEnv.DELIVERY_QUEUE, resolveRequests);
+    await enqueueDeliveryResolutionJobs(
+      db,
+      queueEnv.DELIVERY_QUEUE,
+      planned.unknownRecipients.map((recipientActorApId) => ({
+        activityId: remoteActivityId,
+        recipientActorApId,
+      })),
+    );
   }
 
-  // TODO(remote-inbox-optimization): when the community has a large remote
-  // footprint, prefer delivering once to each remote server's shared inbox via
-  // the community's own followers collection rather than expanding the full
-  // member/follower set here. Local delivery and community audience/addressing
-  // are already correct; this is purely a remote fan-out efficiency follow-up.
+  if (pageActorApIds.length === FANOUT_FOLLOWER_PAGE_SIZE) {
+    await enqueueContinuation(stage, pageActorApIds[pageActorApIds.length - 1]);
+  } else if (stage === "remote_members") {
+    await enqueueContinuation("remote_followers", null);
+  } else {
+    await completeDeliveryFanoutJob(db, intent);
+  }
 
+  // TODO(remote-inbox-optimization): prefer one shared-inbox delivery per
+  // remote server when a community has a very large remote footprint. The
+  // stage/cursor lifecycle above is complete; this is an efficiency follow-up.
   message.ack();
 }
 
@@ -477,11 +588,88 @@ export async function processResolveActor(
 ): Promise<void> {
   if (!requireQueue(env, "resolve_actor", message)) return;
 
+  const resolutionClaim = await claimDeliveryResolutionJob(
+    db,
+    msg.activityId,
+    msg.recipientActorApId,
+  );
+  if (resolutionClaim.state === "terminal") {
+    message.ack();
+    return;
+  }
+  if (
+    resolutionClaim.state === "deferred" ||
+    resolutionClaim.state === "busy"
+  ) {
+    message.retry({ delaySeconds: resolutionClaim.delaySeconds });
+    return;
+  }
+  const managedClaim =
+    resolutionClaim.state === "claimed" ? resolutionClaim : null;
+
+  // A projection cascade may delete the Activity while an old resolve message
+  // remains in flight. Never recreate delivery work for a deleted Activity.
+  const activityExists = await db
+    .select({ apId: activities.apId })
+    .from(activities)
+    .where(eq(activities.apId, msg.activityId))
+    .get();
+  if (!activityExists) {
+    if (managedClaim) {
+      await completeDeliveryResolutionJob(
+        db,
+        managedClaim,
+        "discarded",
+        "activity_not_found",
+      );
+    }
+    message.ack();
+    return;
+  }
+
+  // A verified self-Delete is durable recipient authority. The Delete handler
+  // normally removes actor-addressed resolution rows atomically, but an
+  // already-claimed Queue message may outlive that row. Fence it here before
+  // any remote fetch or endpoint materialization; endpoint jobs may aggregate
+  // a shared inbox and therefore cannot safely be cancelled per actor later.
+  if (await isRemoteActorTombstoned(db, msg.recipientActorApId)) {
+    if (managedClaim) {
+      await completeDeliveryResolutionJob(
+        db,
+        managedClaim,
+        "discarded",
+        "recipient_tombstoned",
+      );
+    }
+    message.ack();
+    return;
+  }
+
   // Defense-in-depth: the fanout/enqueue side already drops blocked recipients
   // via planEndpointsFromActorCache, but enforce the operator blocklist at the
   // resolve seam too so a re-resolved actor (or a domain blocked after enqueue)
   // never gets a delivery job. ACK silently — same posture as the inbox handler.
-  if (await isActorBlocked(db, msg.recipientActorApId)) {
+  let recipientBlocked: boolean;
+  try {
+    recipientBlocked = await isActorBlockedStrict(db, msg.recipientActorApId);
+  } catch (error) {
+    if (managedClaim) {
+      const owned = await deferDeliveryResolutionJob(db, managedClaim, error);
+      if (owned) message.retry({ delaySeconds: 60 });
+      else message.ack();
+      return;
+    }
+    throw error;
+  }
+  if (recipientBlocked) {
+    if (managedClaim) {
+      await completeDeliveryResolutionJob(
+        db,
+        managedClaim,
+        "discarded",
+        "recipient_blocked",
+      );
+    }
     message.ack();
     return;
   }
@@ -504,6 +692,37 @@ export async function processResolveActor(
     try {
       await fetchAndCacheRemoteActor(db, msg.recipientActorApId);
     } catch (e) {
+      if (managedClaim) {
+        const result = await retryDeliveryResolutionJob(db, managedClaim, e);
+        const nextAttempt = managedClaim.attempts + 1;
+        if (!result.owned) {
+          message.ack();
+          return;
+        }
+        if (result.terminal) {
+          log.warn("resolve_actor giving up after max attempts", {
+            event: "delivery.resolve_actor.exhausted",
+            actor: msg.recipientActorApId,
+            activityId: msg.activityId,
+            attempts: nextAttempt,
+            error: e,
+          });
+          message.ack();
+          return;
+        }
+        log.warn("resolve_actor fetch failed", {
+          event: "delivery.resolve_actor.failed",
+          actor: msg.recipientActorApId,
+          activityId: msg.activityId,
+          attempt: nextAttempt,
+          error: e,
+        });
+        // The retry intent is already durable. Ask the current queue message to
+        // retry too; if that signal is lost, the outbox sweep republishes it.
+        message.retry({ delaySeconds: 60 });
+        return;
+      }
+
       // Bound the retry: a permanently-unresolvable recipient (dead host,
       // persistent 5xx, SSRF-blocked) must NOT re-enqueue a fresh resolve_actor
       // every 60s forever. Give up after MAX_RESOLVE_ATTEMPTS so the activity is
@@ -557,13 +776,38 @@ export async function processResolveActor(
       actor: msg.recipientActorApId,
       activityId: msg.activityId,
     });
+    if (managedClaim) {
+      await completeDeliveryResolutionJob(
+        db,
+        managedClaim,
+        "discarded",
+        "endpoint_unresolved",
+      );
+    }
     message.ack();
     return;
   }
 
   const jobId = await computeDeliveryJobId(msg.activityId, endpoint);
-  await upsertDeliveryJob(db, jobId, msg.activityId, endpoint);
+  const active = await upsertDeliveryJob(db, jobId, msg.activityId, endpoint, [
+    msg.recipientActorApId,
+  ]);
+  if (!active) {
+    if (managedClaim) {
+      await completeDeliveryResolutionJob(
+        db,
+        managedClaim,
+        "discarded",
+        "recipient_tombstoned",
+      );
+    }
+    message.ack();
+    return;
+  }
   await sendQueueMessage(env, buildDeliverEndpointMessage(jobId));
+  if (managedClaim) {
+    await completeDeliveryResolutionJob(db, managedClaim, "resolved");
+  }
   message.ack();
 }