@takosjp/yurucommu-core 3.4.3 → 3.4.4

package/packages/api/src/lib/rtc-client.ts

@@ -19,6 +19,8 @@ import type {
   HubToClientFrame,
   IceServerConfig,
 } from "../types/call.ts";
+import { apiPost } from "./api/fetch.ts";
+import { getYurucommuApiTransport } from "./transport.ts";
 
 export type CallUiState =
   | "idle"
@@ -45,7 +47,7 @@ export interface CallClientEvents {
 }
 
 export interface CallClientOptions {
-  /** Origin the app is served from (defaults to the page origin). */
+  /** Explicit server-origin override; otherwise the configured API transport owns it. */
   origin?: string;
   /** WebSocket reconnect backoff ceiling (ms). */
   maxBackoffMs?: number;
@@ -67,12 +69,15 @@ interface ActiveCall {
 }
 
 const CANDIDATE_FLUSH_MS = 200;
+const MAX_PENDING_SOCKET_FRAMES = 64;
 
 export class CallClient {
   private ws: WebSocket | null = null;
   private wantConnected = false;
   private backoff = 500;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private openingSocket = false;
+  private readonly pendingFrames: ClientToHubFrame[] = [];
   private readonly listeners = new Map<keyof CallClientEvents, Set<Listener>>();
   private call: ActiveCall | null = null;
   private localStream: MediaStream | null = null;
@@ -114,16 +119,24 @@ export class CallClient {
   }
 
   // --- connection -----------------------------------------------------------
-  private origin(): string {
-    return (
-      this.options.origin ??
-      (typeof location !== "undefined" ? location.origin : "")
-    );
+  private apiUrl(path: string): string {
+    const origin = this.options.origin;
+    return origin ? new URL(path, `${origin}/`).toString() : path;
   }
 
-  private socketUrl(): string {
-    const o = this.origin();
-    return `${o.replace(/^http/, "ws")}/api/rtc/socket`;
+  private socketUrl(actorApId: string, ticket: string): string {
+    const transport = getYurucommuApiTransport();
+    const resolved = transport.resolveUrl(this.apiUrl("/api/rtc/socket"));
+    const base =
+      this.options.origin ??
+      (typeof location !== "undefined" ? location.origin : "http://localhost");
+    const url = new URL(resolved, base);
+    if (url.protocol === "http:") url.protocol = "ws:";
+    else if (url.protocol === "https:") url.protocol = "wss:";
+    else throw new Error("call socket URL must use HTTP(S)");
+    url.searchParams.set("actor", actorApId);
+    url.searchParams.set("ticket", ticket);
+    return url.toString();
   }
 
   connect(): void {
@@ -137,13 +150,46 @@ export class CallClient {
     this.reconnectTimer = null;
     this.ws?.close();
     this.ws = null;
+    this.pendingFrames.length = 0;
   }
 
   private openSocket(): void {
     if (this.ws && this.ws.readyState <= WebSocket.OPEN) return;
+    if (this.openingSocket) return;
+    this.openingSocket = true;
+    void this.openSocketWithTicket().finally(() => {
+      this.openingSocket = false;
+    });
+  }
+
+  private async openSocketWithTicket(): Promise<void> {
+    let actorApId: string;
+    let ticket: string;
+    try {
+      const response = await apiPost(this.apiUrl("/api/rtc/ticket"));
+      if (!response.ok) throw new Error(`ticket ${response.status}`);
+      const body = (await response.json()) as {
+        actor_ap_id?: unknown;
+        ticket?: unknown;
+      };
+      if (
+        typeof body.actor_ap_id !== "string" ||
+        typeof body.ticket !== "string"
+      ) {
+        throw new Error("bad ticket response");
+      }
+      actorApId = body.actor_ap_id;
+      ticket = body.ticket;
+    } catch (err) {
+      this.emit("error", "socket_ticket_failed", String(err));
+      this.scheduleReconnect();
+      return;
+    }
+    if (!this.wantConnected) return;
+
     let socket: WebSocket;
     try {
-      socket = new WebSocket(this.socketUrl());
+      socket = new WebSocket(this.socketUrl(actorApId, ticket));
     } catch (err) {
       this.emit("error", "socket_open_failed", String(err));
       this.scheduleReconnect();
@@ -152,8 +198,22 @@ export class CallClient {
     this.ws = socket;
     socket.onopen = () => {
       this.backoff = 500;
-      this.send({ t: "hello" });
-      if (this.call) this.send({ t: "resume", callId: this.call.callId });
+      socket.send(JSON.stringify({ t: "hello" } satisfies ClientToHubFrame));
+      const pending = this.pendingFrames.splice(0);
+      const hasInitialInvite =
+        this.call !== null &&
+        pending.some(
+          (frame) => frame.t === "invite" && frame.callId === this.call?.callId,
+        );
+      if (this.call && !hasInitialInvite) {
+        socket.send(
+          JSON.stringify({
+            t: "resume",
+            callId: this.call.callId,
+          } satisfies ClientToHubFrame),
+        );
+      }
+      for (const frame of pending) socket.send(JSON.stringify(frame));
     };
     socket.onmessage = (ev) => {
       void this.onFrame(ev.data);
@@ -181,7 +241,14 @@ export class CallClient {
   private send(frame: ClientToHubFrame): void {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(frame));
+      return;
     }
+    if (!this.wantConnected) return;
+    if (this.pendingFrames.length >= MAX_PENDING_SOCKET_FRAMES) {
+      this.emit("error", "socket_queue_full");
+      return;
+    }
+    this.pendingFrames.push(frame);
   }
 
   // --- public call control --------------------------------------------------
@@ -189,11 +256,9 @@ export class CallClient {
   /** Place an outgoing call. Fetches a callId + ICE, then rings the peer. */
   async startCall(peer: string, media: CallMediaKind): Promise<void> {
     if (this.call) throw new Error("already in a call");
-    const res = await fetch(`${this.origin()}/api/rtc/calls`, {
-      method: "POST",
-      credentials: "include",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ to: peer, media }),
+    const res = await apiPost(this.apiUrl("/api/rtc/calls"), {
+      to: peer,
+      media,
     });
     if (!res.ok) {
       const code = res.status === 403 ? "blocked" : "start_failed";
@@ -204,18 +269,19 @@ export class CallClient {
       callId: string;
       iceServers: IceServerConfig[];
     };
-    this.call = this.newCall(
+    const call = this.newCall(
       data.callId,
       peer,
       media,
       "caller",
       data.iceServers,
     );
+    this.call = call;
     this.setState("calling");
     this.connect();
     this.send({ t: "invite", callId: data.callId, to: peer, media });
-    await this.setupMedia(this.call);
-    await this.makeOffer(this.call);
+    if (!(await this.setupMedia(call))) return;
+    await this.makeOffer(call);
   }
 
   /** Accept the current incoming call. */
@@ -224,11 +290,14 @@ export class CallClient {
     if (!call || call.role !== "callee") return;
     this.setState("connecting");
     this.send({ t: "accept", callId: call.callId });
-    await this.setupMedia(call);
+    if (!(await this.setupMedia(call))) return;
     // The offer was already applied on arrival; create + send the answer.
-    if (call.pc && call.remoteDescriptionSet) {
-      const answer = await call.pc.createAnswer();
-      await call.pc.setLocalDescription(answer);
+    const pc = call.pc;
+    if (pc && call.remoteDescriptionSet && this.isActiveCall(call)) {
+      const answer = await pc.createAnswer();
+      if (!this.isActivePeer(call, pc)) return;
+      await pc.setLocalDescription(answer);
+      if (!this.isActivePeer(call, pc)) return;
       this.send({ t: "answer", callId: call.callId, sdp: answer.sdp ?? "" });
     }
   }
@@ -412,24 +481,45 @@ export class CallClient {
   }
 
   // --- media + peer connection ---------------------------------------------
-  private async setupMedia(call: ActiveCall): Promise<void> {
+  private isActiveCall(call: ActiveCall): boolean {
+    return this.call === call;
+  }
+
+  private isActivePeer(call: ActiveCall, pc: RTCPeerConnection): boolean {
+    return this.isActiveCall(call) && call.pc === pc;
+  }
+
+  private async setupMedia(call: ActiveCall): Promise<boolean> {
+    if (!this.isActiveCall(call)) return false;
     if (!this.localStream) {
+      let stream: MediaStream;
       try {
-        this.localStream = await navigator.mediaDevices.getUserMedia({
+        stream = await navigator.mediaDevices.getUserMedia({
           audio: call.media.audio,
           video: call.media.video,
         });
       } catch (err) {
+        if (!this.isActiveCall(call)) return false;
         this.emit("error", "media_denied", String(err));
         this.hangup("media_denied");
-        return;
+        return false;
+      }
+      if (!this.isActiveCall(call)) {
+        // Permission prompts resolve asynchronously. If the user cancelled or
+        // another call replaced this one while the prompt was open, the newly
+        // acquired tracks have no owner and must be stopped immediately.
+        stream.getTracks().forEach((track) => track.stop());
+        return false;
       }
+      this.localStream = stream;
       this.emit("localstream", this.localStream);
     }
+    if (!this.isActiveCall(call)) return false;
     if (!call.pc) this.buildPeerConnection(call);
     for (const track of this.localStream.getTracks()) {
       call.pc?.addTrack(track, this.localStream);
     }
+    return this.isActiveCall(call);
   }
 
   private buildPeerConnection(call: ActiveCall): void {
@@ -441,13 +531,16 @@ export class CallClient {
       })),
     });
     pc.onicecandidate = (ev) => {
+      if (!this.isActivePeer(call, pc)) return;
       if (ev.candidate) this.bufferCandidate(call, ev.candidate.toJSON());
       else this.flushCandidates(call);
     };
     pc.ontrack = (ev) => {
+      if (!this.isActivePeer(call, pc)) return;
       this.emit("remotestream", ev.streams[0] ?? null);
     };
     pc.onconnectionstatechange = () => {
+      if (!this.isActivePeer(call, pc)) return;
       if (pc.connectionState === "connected") this.setState("connected");
       else if (
         pc.connectionState === "failed" ||
@@ -460,9 +553,14 @@ export class CallClient {
   }
 
   private async makeOffer(call: ActiveCall): Promise<void> {
+    if (!this.isActiveCall(call)) return;
     if (!call.pc) this.buildPeerConnection(call);
-    const offer = await call.pc!.createOffer();
-    await call.pc!.setLocalDescription(offer);
+    const pc = call.pc;
+    if (!pc) return;
+    const offer = await pc.createOffer();
+    if (!this.isActivePeer(call, pc)) return;
+    await pc.setLocalDescription(offer);
+    if (!this.isActivePeer(call, pc)) return;
     this.send({ t: "offer", callId: call.callId, sdp: offer.sdp ?? "" });
   }
 

package/src/backend/federation-helpers.ts

@@ -11,6 +11,7 @@ export {
   activityApId,
   actorApId,
   communityApId,
+  formatPreferredUsername,
   formatUsername,
   generateId,
   getDomain,

package/src/backend/index.ts

@@ -47,7 +47,7 @@ import {
 import { logger } from "./lib/logger.ts";
 
 const log = logger.child({ component: "backend.index" });
-let lastNotificationPushRecoverySweep = 0;
+let lastOutboxRecoverySweep = 0;
 import type { IQueueBatch } from "./runtime/queue.ts";
 import type {
   D1Database,
@@ -63,9 +63,12 @@ import type {
   DeliveryQueueMessageV1,
 } from "./lib/delivery/types.ts";
 import {
+  enqueuePendingDeliveryEndpointJobs,
   handleDeliveryDlqBatch,
   handleDeliveryQueueBatch,
 } from "./lib/delivery/queue.ts";
+import { enqueuePendingDeliveryResolutionJobs } from "./lib/delivery/resolution-outbox.ts";
+import { enqueuePendingDeliveryFanoutJobs } from "./lib/delivery/fanout-outbox.ts";
 import { enqueuePendingNotificationPushJobs } from "./lib/notification-push.ts";
 import { runYurucommuRetention } from "./retention.ts";
 
@@ -620,10 +623,20 @@ function applyGlobalMiddleware(
     const method = c.req.method.toUpperCase();
     const now = Date.now();
     const mutating = !["GET", "HEAD", "OPTIONS"].includes(method);
-    const recoveryDue = now - lastNotificationPushRecoverySweep >= 60_000;
+    const recoveryDue = now - lastOutboxRecoverySweep >= 60_000;
     if (mutating || recoveryDue) {
-      if (recoveryDue) lastNotificationPushRecoverySweep = now;
+      if (recoveryDue) lastOutboxRecoverySweep = now;
       const sweep = (async () => {
+        try {
+          await enqueuePendingDeliveryFanoutJobs(c.env);
+          await enqueuePendingDeliveryEndpointJobs(c.env);
+          await enqueuePendingDeliveryResolutionJobs(c.env);
+        } catch (error) {
+          log.error("Failed to enqueue durable federation outbox", {
+            event: "delivery.outbox.enqueue_failed",
+            error,
+          });
+        }
         try {
           await enqueuePendingNotificationPushJobs(c.env);
         } catch (error) {

package/src/backend/lib/account-migration.ts

@@ -9,6 +9,14 @@ import { signRequest } from "./ap-signing.ts";
 import type { RemoteFetchSigner } from "./activitypub-actor-cache.ts";
 import { parseWebFinger } from "./activitypub-validators.ts";
 import { isSafeRemoteUrl, normalizeRemoteDomain } from "./ssrf.ts";
+import type { Env } from "../types.ts";
+import type { Database, D1Statement } from "../../db/index.ts";
+import { activities, actors, follows, runBatch } from "../../db/index.ts";
+import { and, asc, eq, exists, gt, ne, notExists, sql } from "drizzle-orm";
+import { alias } from "drizzle-orm/sqlite-core";
+import { activityApId } from "./ap-ids.ts";
+import { enqueueDeliveriesToActor } from "./delivery/queue.ts";
+import { sha256Hex } from "./delivery/transformers.ts";
 
 const ALIAS_FETCH_TIMEOUT_MS = 15000;
 
@@ -104,3 +112,335 @@ export async function destinationDeclaresAlias(
     return false;
   }
 }
+
+// ---------------------------------------------------------------------------
+// Inbound Move follow-graph rewrite
+// ---------------------------------------------------------------------------
+
+const MOVE_REFOLLOW_PAGE_SIZE = 100;
+
+/**
+ * Stable namespace for the outbound Follow activities produced by one inbound
+ * Move. The inbox stamps a fixed-size, signer-bound internal activity id before
+ * dispatch; the old/new ids are mixed in as defense-in-depth and to keep direct
+ * handler tests deterministic when no inbox id is supplied.
+ */
+export async function moveRefollowPrefix(args: {
+  readonly baseUrl: string;
+  readonly inboundActivityId?: string;
+  readonly oldActorApId: string;
+  readonly newActorApId: string;
+}): Promise<string> {
+  const digest = await sha256Hex(
+    `${args.inboundActivityId ?? "synthetic-move"}\0${args.oldActorApId}\0${args.newActorApId}`,
+  );
+  return activityApId(args.baseUrl, `move-refollow-${digest}-`);
+}
+
+/**
+ * Re-enqueue every durable local re-Follow created for one Move. Returns the
+ * number of persisted activities found, so the handler can resume a graph
+ * rewrite that committed before a Queue send failed without re-fetching the
+ * destination alias or trying to reconstruct already-deleted old edges.
+ */
+export async function enqueuePersistedMoveRefollows(args: {
+  readonly db: Database;
+  readonly env: Env;
+  readonly newActorApId: string;
+  readonly refollowPrefix: string;
+}): Promise<number> {
+  let cursor: string | null = null;
+  let found = 0;
+
+  while (true) {
+    const page = await args.db
+      .select({ apId: activities.apId })
+      .from(activities)
+      .where(
+        and(
+          eq(activities.type, "Follow"),
+          eq(activities.objectApId, args.newActorApId),
+          eq(activities.direction, "outbound"),
+          // `LIKE prefix%` would hit D1's short LIKE-pattern complexity limit
+          // because the stable prefix contains a full URL + SHA-256 digest.
+          sql`instr(${activities.apId}, ${args.refollowPrefix}) = 1`,
+          cursor ? gt(activities.apId, cursor) : undefined,
+        ),
+      )
+      .orderBy(asc(activities.apId))
+      .limit(MOVE_REFOLLOW_PAGE_SIZE);
+
+    if (page.length === 0) break;
+    await enqueueDeliveriesToActor(
+      args.env,
+      page.map((row) => row.apId),
+      args.newActorApId,
+    );
+    found += page.length;
+    cursor = page[page.length - 1]!.apId;
+    if (page.length < MOVE_REFOLLOW_PAGE_SIZE) break;
+  }
+
+  return found;
+}
+
+/**
+ * Atomically rewrite every edge that names a moved remote actor.
+ *
+ * The statement count is fixed at eight regardless of graph size. Each INSERT
+ * reads the old graph with INSERT ... SELECT, so it binds only the handful of
+ * actor/prefix values rather than six parameters per edge. Both counter repairs
+ * are set-based UPDATEs. This is deliberately not implemented as insertMany()
+ * chunks: a large graph would eventually exceed the 50-statement atomic-batch
+ * ceiling, while splitting the delete/insert work across batches would expose
+ * a permanent half-migrated graph after a crash.
+ *
+ * Outbound local re-Follow activities are written in the same batch as their
+ * pending edges. If Queue delivery throws after commit, the stable prefix lets
+ * a retry call enqueuePersistedMoveRefollows() before touching the graph.
+ */
+export async function rewriteMovedFollowGraph(args: {
+  readonly db: Database;
+  readonly oldActorApId: string;
+  readonly newActorApId: string;
+  readonly refollowPrefix: string;
+}): Promise<void> {
+  const oldAsFollower = alias(follows, "move_old_as_follower");
+  const oldAsFollowee = alias(follows, "move_old_as_followee");
+  const existingFollowerTarget = alias(
+    follows,
+    "move_existing_follower_target",
+  );
+  const existingFollowingSource = alias(
+    follows,
+    "move_existing_following_source",
+  );
+  const localFollowerActor = alias(actors, "move_local_follower_actor");
+
+  // These aliases belong to the counter statements. Keep them separate from
+  // the INSERT aliases so each generated statement is unambiguous to SQLite.
+  const acceptedOldFollowee = alias(follows, "move_accepted_old_followee");
+  const acceptedOldFollower = alias(follows, "move_accepted_old_follower");
+  const duplicateNewFollower = alias(follows, "move_duplicate_new_follower");
+
+  const decrementLocalFollowers = args.db
+    .update(actors)
+    .set({ followingCount: sql`${actors.followingCount} - 1` })
+    .where(
+      and(
+        gt(actors.followingCount, 0),
+        exists(
+          args.db
+            .select({ one: sql`1` })
+            .from(acceptedOldFollowee)
+            .where(
+              and(
+                eq(acceptedOldFollowee.followingApId, args.oldActorApId),
+                eq(acceptedOldFollowee.followerApId, actors.apId),
+                eq(acceptedOldFollowee.status, "accepted"),
+              ),
+            ),
+        ),
+      ),
+    );
+
+  const decrementDroppedLocalFollowees = args.db
+    .update(actors)
+    .set({ followerCount: sql`${actors.followerCount} - 1` })
+    .where(
+      and(
+        gt(actors.followerCount, 0),
+        exists(
+          args.db
+            .select({ one: sql`1` })
+            .from(acceptedOldFollower)
+            .where(
+              and(
+                eq(acceptedOldFollower.followerApId, args.oldActorApId),
+                eq(acceptedOldFollower.followingApId, actors.apId),
+                eq(acceptedOldFollower.status, "accepted"),
+              ),
+            ),
+        ),
+        sql`(
+          ${actors.apId} = ${args.newActorApId}
+          OR ${exists(
+            args.db
+              .select({ one: sql`1` })
+              .from(duplicateNewFollower)
+              .where(
+                and(
+                  eq(duplicateNewFollower.followerApId, args.newActorApId),
+                  eq(duplicateNewFollower.followingApId, actors.apId),
+                ),
+              ),
+          )}
+        )`,
+      ),
+    );
+
+  const rewriteOldAsFollower = args.db
+    .insert(follows)
+    .select(
+      args.db
+        .select({
+          followerApId: sql<string>`${args.newActorApId}`.as("follower_ap_id"),
+          followingApId: oldAsFollower.followingApId,
+          status: oldAsFollower.status,
+          activityApId: oldAsFollower.activityApId,
+          createdAt: oldAsFollower.createdAt,
+          acceptedAt: oldAsFollower.acceptedAt,
+        })
+        .from(oldAsFollower)
+        .where(
+          and(
+            eq(oldAsFollower.followerApId, args.oldActorApId),
+            ne(oldAsFollower.followingApId, args.newActorApId),
+            notExists(
+              args.db
+                .select({ one: sql`1` })
+                .from(existingFollowerTarget)
+                .where(
+                  and(
+                    eq(existingFollowerTarget.followerApId, args.newActorApId),
+                    eq(
+                      existingFollowerTarget.followingApId,
+                      oldAsFollower.followingApId,
+                    ),
+                  ),
+                ),
+            ),
+          ),
+        ),
+    )
+    .onConflictDoNothing();
+
+  const localFollowerExists = exists(
+    args.db
+      .select({ one: sql`1` })
+      .from(localFollowerActor)
+      .where(eq(localFollowerActor.apId, oldAsFollowee.followerApId)),
+  );
+  const targetEdgeDoesNotExist = notExists(
+    args.db
+      .select({ one: sql`1` })
+      .from(existingFollowingSource)
+      .where(
+        and(
+          eq(existingFollowingSource.followerApId, oldAsFollowee.followerApId),
+          eq(existingFollowingSource.followingApId, args.newActorApId),
+        ),
+      ),
+  );
+
+  const rewriteLocalFollowers = args.db
+    .insert(follows)
+    .select(
+      args.db
+        .select({
+          followerApId: oldAsFollowee.followerApId,
+          followingApId: sql<string>`${args.newActorApId}`.as(
+            "following_ap_id",
+          ),
+          status: sql<string>`'pending'`.as("status"),
+          activityApId:
+            sql<string>`${args.refollowPrefix} || lower(hex(randomblob(32)))`.as(
+              "activity_ap_id",
+            ),
+          createdAt: oldAsFollowee.createdAt,
+          acceptedAt: sql<null>`NULL`.as("accepted_at"),
+        })
+        .from(oldAsFollowee)
+        .where(
+          and(
+            eq(oldAsFollowee.followingApId, args.oldActorApId),
+            ne(oldAsFollowee.followerApId, args.newActorApId),
+            targetEdgeDoesNotExist,
+            localFollowerExists,
+          ),
+        ),
+    )
+    .onConflictDoNothing();
+
+  const rewriteRemoteFollowers = args.db
+    .insert(follows)
+    .select(
+      args.db
+        .select({
+          followerApId: oldAsFollowee.followerApId,
+          followingApId: sql<string>`${args.newActorApId}`.as(
+            "following_ap_id",
+          ),
+          status: oldAsFollowee.status,
+          activityApId: oldAsFollowee.activityApId,
+          createdAt: oldAsFollowee.createdAt,
+          acceptedAt: oldAsFollowee.acceptedAt,
+        })
+        .from(oldAsFollowee)
+        .where(
+          and(
+            eq(oldAsFollowee.followingApId, args.oldActorApId),
+            ne(oldAsFollowee.followerApId, args.newActorApId),
+            targetEdgeDoesNotExist,
+            notExists(
+              args.db
+                .select({ one: sql`1` })
+                .from(localFollowerActor)
+                .where(eq(localFollowerActor.apId, oldAsFollowee.followerApId)),
+            ),
+          ),
+        ),
+    )
+    .onConflictDoNothing();
+
+  const migratedLocalFollow = alias(follows, "move_migrated_local_follow");
+  const recordLocalRefollows = args.db
+    .insert(activities)
+    .select(
+      args.db
+        .select({
+          apId: migratedLocalFollow.activityApId,
+          type: sql<string>`'Follow'`.as("type"),
+          actorApId: migratedLocalFollow.followerApId,
+          objectApId: sql<string>`${args.newActorApId}`.as("object_ap_id"),
+          objectJson: sql<null>`NULL`.as("object_json"),
+          targetApId: sql<null>`NULL`.as("target_ap_id"),
+          rawJson: sql<string>`json_object(
+            '@context', 'https://www.w3.org/ns/activitystreams',
+            'id', ${migratedLocalFollow.activityApId},
+            'type', 'Follow',
+            'actor', ${migratedLocalFollow.followerApId},
+            'object', ${args.newActorApId}
+          )`.as("raw_json"),
+          direction: sql<string>`'outbound'`.as("direction"),
+          processed: sql<number>`0`.as("processed"),
+          createdAt: sql<string>`datetime('now')`.as("created_at"),
+        })
+        .from(migratedLocalFollow)
+        .where(
+          and(
+            eq(migratedLocalFollow.followingApId, args.newActorApId),
+            sql`instr(${migratedLocalFollow.activityApId}, ${args.refollowPrefix}) = 1`,
+          ),
+        ),
+    )
+    .onConflictDoNothing();
+
+  const deleteOldAsFollower = args.db
+    .delete(follows)
+    .where(eq(follows.followerApId, args.oldActorApId));
+  const deleteOldAsFollowee = args.db
+    .delete(follows)
+    .where(eq(follows.followingApId, args.oldActorApId));
+
+  await runBatch(args.db, [
+    decrementLocalFollowers,
+    decrementDroppedLocalFollowees,
+    rewriteOldAsFollower,
+    rewriteLocalFollowers,
+    rewriteRemoteFollowers,
+    recordLocalRefollows,
+    deleteOldAsFollower,
+    deleteOldAsFollowee,
+  ] as unknown as [D1Statement, ...D1Statement[]]);
+}