@oxy.so/federation 2.2.1 → 2.4.0

package/src/__tests__/delivery.test.ts

@@ -2,6 +2,7 @@ import { Readable } from 'node:stream';
 import { createDomainPolicy } from '../apUri';
 import {
   createDeliveryService,
+  DeliveryAuthorizationDeniedError,
   type DeliveryServiceConfig,
   type DeliveryActorFields,
   type DeliveryQueueJob,
@@ -29,25 +30,36 @@ interface StoredActor extends DeliveryActorFields {
 }
 
 /** A capturing test rig: records every delivered/queued activity + enqueue jobs. */
-function makeRig(overrides: {
-  actorsByUri?: Record<string, StoredActor>;
-  followerActorUris?: string[];
-  followerInboxes?: Record<string, { sharedInboxUrl?: string | null; inboxUrl?: string | null }>;
-  enqueueReturns?: boolean;
-  federationEnabled?: boolean;
-  sharingEnabled?: boolean;
-  assertSafeInboxUrl?: DeliveryServiceConfig<StoredActor>['assertSafeInboxUrl'];
-  blockedHosts?: string[];
-} = {}) {
+function makeRig(
+  overrides: {
+    actorsByUri?: Record<string, StoredActor>;
+    followerActorUris?: string[];
+    followerInboxes?: Record<string, { sharedInboxUrl?: string | null; inboxUrl?: string | null }>;
+    enqueueReturns?: boolean;
+    federationEnabled?: boolean;
+    sharingEnabled?: boolean;
+    assertSafeInboxUrl?: DeliveryServiceConfig<StoredActor>['assertSafeInboxUrl'];
+    blockedHosts?: string[];
+    authorizeDelivery?: DeliveryServiceConfig<StoredActor>['authorizeDelivery'];
+  } = {},
+) {
   const deliveredBodies: Array<{ url: string; body: string }> = [];
   const enqueued: DeliveryQueueJob[] = [];
   const fallbackCreates: Array<DeliveryQueueJob & { nextAttemptAt: Date }> = [];
   const fallbackInserts: Array<DeliveryQueueJob & { nextAttemptAt: Date }> = [];
-  const upsertedFollows: Array<{ localOxyUserId: string; remoteActorUri: string; activityId: string }> = [];
+  const upsertedFollows: Array<{
+    localOxyUserId: string;
+    remoteActorUri: string;
+    activityId: string;
+  }> = [];
   const deletedFollowIds: unknown[] = [];
   const refreshedInBackground: string[] = [];
 
-  const sign: HttpSignatureSigner = async () => 'TESTSIG';
+  const signatures: string[] = [];
+  const sign: HttpSignatureSigner = async (keyId) => {
+    signatures.push(keyId);
+    return 'TESTSIG';
+  };
   const domainPolicy =
     overrides.blockedHosts === undefined
       ? createDomainPolicy({ domain: DOMAIN })
@@ -55,6 +67,7 @@ function makeRig(overrides: {
 
   const config: DeliveryServiceConfig<StoredActor> = {
     federationEnabled: overrides.federationEnabled ?? true,
+    authorizeDelivery: overrides.authorizeDelivery,
     userAgent: 'Mention/mention.earth (ActivityPub)',
     apContentType: 'application/activity+json',
     keys: {
@@ -65,7 +78,10 @@ function makeRig(overrides: {
     deliverSingleHop: async (url, init): Promise<DeliverSingleHopResult> => {
       deliveredBodies.push({ url, body: init.body });
       // 202 Accepted — success path (response body destroyed, never read).
-      return { response: Readable.from([]) as unknown as DeliverSingleHopResult['response'], status: 202 };
+      return {
+        response: Readable.from([]) as unknown as DeliverSingleHopResult['response'],
+        status: 202,
+      };
     },
     assertSafeInboxUrl: overrides.assertSafeInboxUrl ?? (async () => ({ ok: true })),
     transport: {
@@ -89,7 +105,10 @@ function makeRig(overrides: {
       findActorInboxesByUris: async (uris) =>
         uris
           .map((u) => overrides.followerInboxes?.[u])
-          .filter((a): a is { sharedInboxUrl?: string | null; inboxUrl?: string | null } => a !== undefined),
+          .filter(
+            (a): a is { sharedInboxUrl?: string | null; inboxUrl?: string | null } =>
+              a !== undefined,
+          ),
     },
     follows: {
       listAcceptedInboundFollowerActorUris: async () => overrides.followerActorUris ?? [],
@@ -98,7 +117,9 @@ function makeRig(overrides: {
       },
       findOutbound: async (_localOxyUserId, remoteActorUri) => {
         const actor = overrides.actorsByUri?.[remoteActorUri];
-        return actor ? { _id: actor._id, activityId: `${urls.actor('alice')}/follows/${String(actor._id)}` } : null;
+        return actor
+          ? { _id: actor._id, activityId: `${urls.actor('alice')}/follows/${String(actor._id)}` }
+          : null;
       },
       deleteById: async (id) => {
         deletedFollowIds.push(id);
@@ -120,13 +141,18 @@ function makeRig(overrides: {
       }),
     },
     profile: { getBanner: async () => 'https://cdn.example/banner.png' },
-    buildLocalActorObject: (params) => ({ id: urls.actor(params.username), type: 'Person', name: params.displayName }),
+    buildLocalActorObject: (params) => ({
+      id: urls.actor(params.username),
+      type: 'Person',
+      name: params.displayName,
+    }),
     logger: { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} },
     isBlockedDomain: domainPolicy.isBlockedDomain,
   };
 
   return {
     service: createDeliveryService(config),
+    signatures,
     deliveredBodies,
     enqueued,
     fallbackCreates,
@@ -173,7 +199,11 @@ describe('sendFollow', () => {
     expect(result).toEqual({ success: true, pending: false });
     expect(rig.refreshedInBackground).toEqual([remote]);
     expect(rig.upsertedFollows).toEqual([
-      { localOxyUserId: 'u-alice', remoteActorUri: remote, activityId: `${urls.actor('alice')}/follows/ACTID` },
+      {
+        localOxyUserId: 'u-alice',
+        remoteActorUri: remote,
+        activityId: `${urls.actor('alice')}/follows/ACTID`,
+      },
     ]);
     // Byte-frozen Follow activity — the bare AS2 context (NOT the full AP_CONTEXT).
     expect(rig.deliveredBodies).toHaveLength(1);
@@ -185,7 +215,11 @@ describe('sendFollow', () => {
 
   it('short-circuits when federation is disabled', async () => {
     const rig = makeRig({ federationEnabled: false });
-    const result = await rig.service.sendFollow('u-alice', 'alice', 'https://remote.example/users/bob');
+    const result = await rig.service.sendFollow(
+      'u-alice',
+      'alice',
+      'https://remote.example/users/bob',
+    );
     expect(result).toEqual({ success: false, pending: false });
     expect(rig.deliveredBodies).toHaveLength(0);
     expect(rig.upsertedFollows).toHaveLength(0);
@@ -214,7 +248,9 @@ describe('sendAccept', () => {
   it('delivers the exact Accept(Follow) activity with the full AP_CONTEXT', async () => {
     const remote = 'https://remote.example/users/bob';
     const rig = makeRig({
-      actorsByUri: { [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://remote.example/inbox' } },
+      actorsByUri: {
+        [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://remote.example/inbox' },
+      },
     });
 
     await rig.service.sendAccept('u-alice', 'alice', 'https://remote.example/follows/1', remote);
@@ -265,7 +301,9 @@ describe('sendAccept', () => {
     const remote = 'https://blocked.example/users/bob';
     const rig = makeRig({
       blockedHosts: ['blocked.example'],
-      actorsByUri: { [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://blocked.example/inbox' } },
+      actorsByUri: {
+        [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://blocked.example/inbox' },
+      },
     });
 
     await rig.service.sendAccept('u-alice', 'alice', 'https://blocked.example/follows/1', remote);
@@ -279,7 +317,9 @@ describe('sendUndoFollow', () => {
   it('deletes the local follow, then delivers the exact Undo(Follow) with AP_CONTEXT', async () => {
     const remote = 'https://remote.example/users/bob';
     const rig = makeRig({
-      actorsByUri: { [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://remote.example/inbox' } },
+      actorsByUri: {
+        [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://remote.example/inbox' },
+      },
     });
 
     const ok = await rig.service.sendUndoFollow('u-alice', 'alice', remote);
@@ -307,7 +347,9 @@ describe('sendUndoFollow', () => {
     const remote = 'https://blocked.example/users/bob';
     const rig = makeRig({
       blockedHosts: ['blocked.example'],
-      actorsByUri: { [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://blocked.example/inbox' } },
+      actorsByUri: {
+        [remote]: { _id: 'A', uri: remote, inboxUrl: 'https://blocked.example/inbox' },
+      },
     });
 
     const ok = await rig.service.sendUndoFollow('u-alice', 'alice', remote);
@@ -366,9 +408,7 @@ describe('deliverToFollowers', () => {
 
   it('skips unsafe inbox URLs instead of enqueueing or falling back', async () => {
     const unsafeGuard = jest.fn(async (url: string) =>
-      url.includes('unsafe')
-        ? { ok: false as const, reason: 'blocked' }
-        : { ok: true as const },
+      url.includes('unsafe') ? { ok: false as const, reason: 'blocked' } : { ok: true as const },
     );
     const rig = makeRig({
       followerActorUris: ['a', 'b'],
@@ -430,3 +470,103 @@ describe('federateActorUpdate', () => {
     expect(rig.enqueued).toHaveLength(0);
   });
 });
+
+describe('live delivery authorization', () => {
+  const activity = {
+    type: 'Create',
+    actor: 'https://untrusted.example/not-the-sender',
+    object: { type: 'Note', content: 'protected' },
+  };
+  const remoteActorUri = 'https://remote.example/users/bob';
+  const actorsByUri = {
+    [remoteActorUri]: { uri: remoteActorUri, inboxUrl: 'https://remote.example/inbox' },
+  };
+
+  it('uses trusted sender metadata and refuses before signing, sending or enqueueing', async () => {
+    const authorizeDelivery = jest.fn(async () => false);
+    const rig = makeRig({ authorizeDelivery });
+    await expect(
+      rig.service.deliverActivity(
+        activity,
+        'https://remote.example/inbox',
+        'canonical-sender',
+        'alice',
+      ),
+    ).rejects.toBeInstanceOf(DeliveryAuthorizationDeniedError);
+    await expect(
+      rig.service.queueDelivery(activity, 'https://remote.example/inbox', 'canonical-sender'),
+    ).rejects.toBeInstanceOf(DeliveryAuthorizationDeniedError);
+    expect(authorizeDelivery).toHaveBeenCalledWith({
+      activity,
+      senderAccountId: 'canonical-sender',
+    });
+    expect(rig.signatures).toEqual([]);
+    expect(rig.deliveredBodies).toEqual([]);
+    expect(rig.enqueued).toEqual([]);
+    expect(rig.fallbackCreates).toEqual([]);
+  });
+
+  it('propagates transient authority failure without disguising it as a denial or send success', async () => {
+    const unavailable = new Error('policy service unavailable');
+    const rig = makeRig({
+      authorizeDelivery: async () => {
+        throw unavailable;
+      },
+    });
+    await expect(
+      rig.service.deliverActivity(activity, 'https://remote.example/inbox', 'sender', 'alice'),
+    ).rejects.toBe(unavailable);
+    expect(rig.signatures).toEqual([]);
+    expect(rig.deliveredBodies).toEqual([]);
+  });
+
+  it('checks internal Follow and Accept paths and does not commit a refused follow', async () => {
+    const rig = makeRig({ actorsByUri, authorizeDelivery: async () => false });
+    await expect(rig.service.sendFollow('sender', 'alice', remoteActorUri)).rejects.toBeInstanceOf(
+      DeliveryAuthorizationDeniedError,
+    );
+    await expect(
+      rig.service.sendAccept('sender', 'alice', 'follow-id', remoteActorUri),
+    ).rejects.toBeInstanceOf(DeliveryAuthorizationDeniedError);
+    await flush();
+    expect(rig.upsertedFollows).toEqual([]);
+    expect(rig.refreshedInBackground).toEqual([]);
+    expect(rig.signatures).toEqual([]);
+    expect(rig.deliveredBodies).toEqual([]);
+    expect(rig.enqueued).toEqual([]);
+  });
+
+  it('authorizes one fanout once and rechecks a durable delivery after revocation', async () => {
+    const authorizeDelivery = jest.fn(async () => true);
+    const rig = makeRig({
+      authorizeDelivery,
+      followerActorUris: ['a', 'b'],
+      followerInboxes: {
+        a: { inboxUrl: 'https://a.example/inbox' },
+        b: { inboxUrl: 'https://b.example/inbox' },
+      },
+    });
+    await rig.service.deliverToFollowers(activity, 'sender', 'alice');
+    expect(authorizeDelivery).toHaveBeenCalledTimes(1);
+    expect(rig.enqueued).toHaveLength(2);
+    authorizeDelivery.mockResolvedValue(false);
+    const job = rig.enqueued[0];
+    await expect(
+      rig.service.deliverActivity(job.activityJson, job.targetInbox, job.senderOxyUserId, 'alice'),
+    ).rejects.toBeInstanceOf(DeliveryAuthorizationDeniedError);
+    expect(rig.signatures).toEqual([]);
+  });
+
+  it('preserves approved adult delivery and checks a Follow once per immediate operation', async () => {
+    const authorizeDelivery = jest.fn(async () => true);
+    const rig = makeRig({ actorsByUri, authorizeDelivery });
+    expect(await rig.service.sendFollow('adult', 'alice', remoteActorUri)).toEqual({
+      success: true,
+      pending: false,
+    });
+    await flush();
+    expect(authorizeDelivery).toHaveBeenCalledTimes(1);
+    expect(rig.deliveredBodies).toHaveLength(1);
+    expect(rig.signatures).toHaveLength(1);
+  });
+});

package/src/__tests__/federationHost.test.ts

@@ -49,7 +49,11 @@ const CASES: ReadonlyArray<{
 }> = [
   { name: 'exact host', actorUri: 'https://spam.example/users/bob', expectedBlocked: true },
   { name: 'uppercase host', actorUri: 'https://SPAM.EXAMPLE/users/bob', expectedBlocked: true },
-  { name: 'www. on the wire', actorUri: 'https://www.spam.example/users/bob', expectedBlocked: true },
+  {
+    name: 'www. on the wire',
+    actorUri: 'https://www.spam.example/users/bob',
+    expectedBlocked: true,
+  },
   {
     name: 'www. on the blocklist entry, bare on the wire',
     actorUri: 'https://spam.example/users/bob',
@@ -86,7 +90,11 @@ const CASES: ReadonlyArray<{
     entry: 'über.example',
     expectedBlocked: false,
   },
-  { name: 'unrelated host', actorUri: 'https://mastodon.social/users/alice', expectedBlocked: false },
+  {
+    name: 'unrelated host',
+    actorUri: 'https://mastodon.social/users/alice',
+    expectedBlocked: false,
+  },
   {
     name: 'blocked host as a subdomain prefix',
     actorUri: 'https://spam.example.evil.test/users/bob',
@@ -227,7 +235,9 @@ describe('canonicalFederationHost', () => {
 
   it('does not convert a unicode host to its punycode wire form', () => {
     expect(canonicalFederationHost('ÜBER.example')).toBe('über.example');
-    expect(canonicalFederationHost('über.example')).not.toBe(new URL('https://über.example').hostname);
+    expect(canonicalFederationHost('über.example')).not.toBe(
+      new URL('https://über.example').hostname,
+    );
   });
 });
 

package/src/__tests__/httpSignature.test.ts

@@ -117,9 +117,7 @@ const fetchPublicKey = async (keyId: string) =>
 
 /** Reproduce how Express lowercases req.headers, folding content-type as a real header. */
 function lowerHeaders(headers: Record<string, string>): Record<string, string> {
-  const lowered = Object.fromEntries(
-    Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]),
-  );
+  const lowered = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
   if (lowered.digest && !lowered['content-type']) {
     lowered['content-type'] = DEFAULT_SIGNED_CONTENT_TYPE;
   }

package/src/__tests__/inboundDispatch.test.ts

@@ -21,21 +21,32 @@ import {
 const LOCAL_ACTOR = 'https://mention.earth/ap/users/alice';
 const REMOTE_ACTOR = 'https://remote.example/users/bob';
 
-function makeRig(overrides: {
-  localUser?: { _id?: string | null; id?: string | null } | null;
-  sharingEnabled?: boolean;
-  followerOxyUserId?: string | null;
-  inboundFollow?: { _id: unknown; localUserId: string } | null;
-  actorOxyUserIdForUndo?: string | null;
-  validate?: (activity: Record<string, unknown>) => InboundActivityValidation;
-  blockedHosts?: string[];
-  withMoveHandler?: boolean;
-} = {}) {
+function makeRig(
+  overrides: {
+    localUser?: { _id?: string | null; id?: string | null } | null;
+    sharingEnabled?: boolean;
+    followerOxyUserId?: string | null;
+    inboundFollow?: { _id: unknown; localUserId: string } | null;
+    actorOxyUserIdForUndo?: string | null;
+    validate?: (activity: Record<string, unknown>) => InboundActivityValidation;
+    blockedHosts?: string[];
+    withMoveHandler?: boolean;
+  } = {},
+) {
   const moves: Array<{ activityId: string; oldActorUri: string; targetActorUri: string }> = [];
   const bridgeFollowCalls: Array<[string, string]> = [];
   const bridgeUnfollowCalls: Array<[string, string]> = [];
-  const acceptsSent: Array<{ localOxyUserId: string; localUsername: string; followActivityId: string; remoteActorUri: string }> = [];
-  const inboundAcceptedUpserts: Array<{ localUserId: string; remoteActorUri: string; activityId: string }> = [];
+  const acceptsSent: Array<{
+    localOxyUserId: string;
+    localUsername: string;
+    followActivityId: string;
+    remoteActorUri: string;
+  }> = [];
+  const inboundAcceptedUpserts: Array<{
+    localUserId: string;
+    remoteActorUri: string;
+    activityId: string;
+  }> = [];
   const deletedFollowIds: unknown[] = [];
   const contentActivities: Array<{ type: unknown; verifiedActorUri: string }> = [];
   const outboundAcceptedByActivityId: Array<[string, string]> = [];
@@ -111,7 +122,11 @@ function makeRig(overrides: {
     ...(overrides.withMoveHandler === false
       ? {}
       : {
-          onMove: async (move: { activityId: string; oldActorUri: string; targetActorUri: string }) => {
+          onMove: async (move: {
+            activityId: string;
+            oldActorUri: string;
+            targetActorUri: string;
+          }) => {
             moves.push(move);
           },
         }),
@@ -145,9 +160,16 @@ describe('inbound Follow', () => {
     );
 
     expect(rig.bridgeFollowCalls).toEqual([['u-bob', 'u-alice']]);
-    expect(rig.inboundAcceptedUpserts).toEqual([{ localUserId: 'u-alice', remoteActorUri: REMOTE_ACTOR, activityId: 'f1' }]);
+    expect(rig.inboundAcceptedUpserts).toEqual([
+      { localUserId: 'u-alice', remoteActorUri: REMOTE_ACTOR, activityId: 'f1' },
+    ]);
     expect(rig.acceptsSent).toEqual([
-      { localOxyUserId: 'u-alice', localUsername: 'alice', followActivityId: 'f1', remoteActorUri: REMOTE_ACTOR },
+      {
+        localOxyUserId: 'u-alice',
+        localUsername: 'alice',
+        followActivityId: 'f1',
+        remoteActorUri: REMOTE_ACTOR,
+      },
     ]);
     expect(rig.onInboundFollowAcceptedCalls).toEqual([['u-alice', 'u-bob', REMOTE_ACTOR]]);
   });
@@ -233,20 +255,32 @@ describe('inbound Accept / Reject', () => {
   it('marks the outbound follow accepted by activity id + triggers the outbox backfill', async () => {
     const rig = makeRig();
     await rig.dispatcher.processInboxActivity(
-      { type: 'Accept', actor: REMOTE_ACTOR, object: { type: 'Follow', id: 'https://mention.earth/ap/users/alice/follows/1' } },
+      {
+        type: 'Accept',
+        actor: REMOTE_ACTOR,
+        object: { type: 'Follow', id: 'https://mention.earth/ap/users/alice/follows/1' },
+      },
       REMOTE_ACTOR,
     );
-    expect(rig.outboundAcceptedByActivityId).toEqual([[REMOTE_ACTOR, 'https://mention.earth/ap/users/alice/follows/1']]);
+    expect(rig.outboundAcceptedByActivityId).toEqual([
+      [REMOTE_ACTOR, 'https://mention.earth/ap/users/alice/follows/1'],
+    ]);
     expect(rig.onOutboundFollowAcceptedCalls).toEqual([REMOTE_ACTOR]);
   });
 
   it('marks accepted (string ref, then any-pending fallback)', async () => {
     const rig = makeRig();
     await rig.dispatcher.processInboxActivity(
-      { type: 'Accept', actor: REMOTE_ACTOR, object: 'https://mention.earth/ap/users/alice/follows/1' },
+      {
+        type: 'Accept',
+        actor: REMOTE_ACTOR,
+        object: 'https://mention.earth/ap/users/alice/follows/1',
+      },
       REMOTE_ACTOR,
     );
-    expect(rig.outboundAcceptedByActivityId).toEqual([[REMOTE_ACTOR, 'https://mention.earth/ap/users/alice/follows/1']]);
+    expect(rig.outboundAcceptedByActivityId).toEqual([
+      [REMOTE_ACTOR, 'https://mention.earth/ap/users/alice/follows/1'],
+    ]);
   });
 
   it('marks the outbound follow rejected on Reject(Follow)', async () => {
@@ -273,13 +307,18 @@ describe('Move → onMove', () => {
   it('hands a well-formed self-Move to the app', async () => {
     const rig = makeRig();
     await rig.dispatcher.processInboxActivity(move(), REMOTE_ACTOR);
-    expect(rig.moves).toEqual([{ activityId: `${REMOTE_ACTOR}#moves/1`, oldActorUri: REMOTE_ACTOR, targetActorUri: TARGET }]);
+    expect(rig.moves).toEqual([
+      { activityId: `${REMOTE_ACTOR}#moves/1`, oldActorUri: REMOTE_ACTOR, targetActorUri: TARGET },
+    ]);
     expect(rig.contentActivities).toHaveLength(0);
   });
 
   it('accepts embedded object/target references', async () => {
     const rig = makeRig();
-    await rig.dispatcher.processInboxActivity(move({ object: { id: REMOTE_ACTOR }, target: { id: TARGET } }), REMOTE_ACTOR);
+    await rig.dispatcher.processInboxActivity(
+      move({ object: { id: REMOTE_ACTOR }, target: { id: TARGET } }),
+      REMOTE_ACTOR,
+    );
     expect(rig.moves).toHaveLength(1);
   });
 
@@ -304,18 +343,23 @@ describe('Move → onMove', () => {
 
   it('drops a Move when the app registered no handler', async () => {
     const rig = makeRig({ withMoveHandler: false });
-    await expect(rig.dispatcher.processInboxActivity(move(), REMOTE_ACTOR)).resolves.toBeUndefined();
+    await expect(
+      rig.dispatcher.processInboxActivity(move(), REMOTE_ACTOR),
+    ).resolves.toBeUndefined();
     expect(rig.contentActivities).toHaveLength(0);
   });
 });
 
 describe('content verbs → onContentActivity', () => {
-  it.each(['Create', 'Announce', 'Like', 'Delete', 'Update'])('routes %s to the app', async (type) => {
-    const rig = makeRig();
-    await rig.dispatcher.processInboxActivity({ type, actor: REMOTE_ACTOR }, REMOTE_ACTOR);
-    expect(rig.contentActivities).toEqual([{ type, verifiedActorUri: REMOTE_ACTOR }]);
-    expect(rig.bridgeFollowCalls).toHaveLength(0);
-  });
+  it.each(['Create', 'Announce', 'Like', 'Delete', 'Update'])(
+    'routes %s to the app',
+    async (type) => {
+      const rig = makeRig();
+      await rig.dispatcher.processInboxActivity({ type, actor: REMOTE_ACTOR }, REMOTE_ACTOR);
+      expect(rig.contentActivities).toEqual([{ type, verifiedActorUri: REMOTE_ACTOR }]);
+      expect(rig.bridgeFollowCalls).toHaveLength(0);
+    },
+  );
 
   it('drops a malformed activity without dispatching', async () => {
     const rig = makeRig({ validate: () => ({ ok: false, summary: 'bad shape' }) });
@@ -402,7 +446,10 @@ describe('blocked-origin domain policy', () => {
 
   it('refuses the origin BEFORE the payload is parsed', async () => {
     const rig = makeRig({ blockedHosts: ['spam.example'] });
-    await rig.dispatcher.processInboxActivity({ type: 'Create', actor: BLOCKED_ACTOR }, BLOCKED_ACTOR);
+    await rig.dispatcher.processInboxActivity(
+      { type: 'Create', actor: BLOCKED_ACTOR },
+      BLOCKED_ACTOR,
+    );
     expect(rig.validatedActivities).toHaveLength(0);
   });
 
@@ -424,7 +471,10 @@ describe('blocked-origin domain policy', () => {
 
   it('still dispatches an allowed origin while another host is blocked', async () => {
     const rig = makeRig({ blockedHosts: ['spam.example'] });
-    await rig.dispatcher.processInboxActivity({ type: 'Create', actor: REMOTE_ACTOR }, REMOTE_ACTOR);
+    await rig.dispatcher.processInboxActivity(
+      { type: 'Create', actor: REMOTE_ACTOR },
+      REMOTE_ACTOR,
+    );
     expect(rig.contentActivities).toEqual([{ type: 'Create', verifiedActorUri: REMOTE_ACTOR }]);
   });