@fedify/fedify 2.0.0-dev.1641 → 2.0.0-dev.1690

package/dist/federation/idempotency.test.js

@@ -0,0 +1,202 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { Create, Follow, Person } from "../type-C69ZBu7f.js";
+import { assertEquals } from "../assert_equals-DSbWqCm3.js";
+import "../assert-MZs1qjMx.js";
+import "../assert_instance_of-DHz7EHNU.js";
+import { MemoryKvStore } from "../kv-CRZrzyXm.js";
+import { createFederation } from "../middleware-DY9B2lL8.js";
+import "../client-CnOdwLLN.js";
+import "../lookup-pV0JOsuV.js";
+import "../types-BSuWJsOm.js";
+import "../actor-DuCeRiNh.js";
+import "../key-1KXru8Ug.js";
+import "../http-BNOYnVsU.js";
+import "../authdocloader-Brax1A32.js";
+import "../ld-Dv8DNNAT.js";
+import "../owner-e3FYDhsk.js";
+import { signObject } from "../proof-6gFMwMNJ.js";
+import "../inbox-BRru9pX3.js";
+import "../builder-CYOcDUkj.js";
+import "../collection-CcnIw1qY.js";
+import "../keycache-CN61iGVj.js";
+import "../negotiation-5NPJL6zp.js";
+import "../retry-D4GJ670a.js";
+import "../send-Tl9NOnmO.js";
+import { mockDocumentLoader, test } from "../testing-BWNCAbL-.js";
+import "../std__assert-X-_kMxKM.js";
+import "../assert_rejects-DiIiJbZn.js";
+import "../assert_is_error-BPGph1Jx.js";
+import "../assert_not_equals-f3m3epl3.js";
+import "../assert_throws-BOO88avQ.js";
+import { ed25519Multikey, ed25519PrivateKey, ed25519PublicKey } from "../keys-BPdFKgiy.js";
+
+//#region src/federation/idempotency.test.ts
+const kv = new MemoryKvStore();
+const federationOptions = {
+	kv,
+	documentLoaderFactory: () => mockDocumentLoader,
+	authenticatedDocumentLoaderFactory: () => mockDocumentLoader
+};
+function createTestFederation() {
+	const federation = createFederation(federationOptions);
+	federation.setActorDispatcher("/users/{identifier}", (_, identifier) => identifier === "john" ? new Person({}) : null).setKeyPairsDispatcher(() => [{
+		privateKey: ed25519PrivateKey,
+		publicKey: ed25519PublicKey.publicKey
+	}]);
+	return federation;
+}
+test("Federation.setInboxListeners().withIdempotency() - per-origin strategy", async () => {
+	const federation = createTestFederation();
+	const processedActivities = [];
+	federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").withIdempotency("per-origin").on(Create, (ctx, activity$1) => {
+		processedActivities.push([ctx.recipient, activity$1]);
+	});
+	const activity = new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person2")
+	});
+	const signedActivity = await signObject(activity, ed25519PrivateKey, ed25519Multikey.id);
+	const body = JSON.stringify(await signedActivity.toJsonLd({ contextLoader: mockDocumentLoader }));
+	let response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	assertEquals(processedActivities[0][0], "john");
+	response = await federation.fetch(new Request("https://example.com/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	await kv.delete([
+		"_fedify",
+		"activityIdempotence",
+		"https://example.com:https://example.com/activities/1"
+	]);
+});
+test("Federation.setInboxListeners().withIdempotency() - per-inbox strategy", async () => {
+	const federation = createTestFederation();
+	const processedActivities = [];
+	federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").withIdempotency("per-inbox").on(Create, (ctx, activity$1) => {
+		processedActivities.push([ctx.recipient, activity$1]);
+	});
+	const activity = new Create({
+		id: new URL("https://example.com/activities/2"),
+		actor: new URL("https://example.com/person2")
+	});
+	const signedActivity = await signObject(activity, ed25519PrivateKey, ed25519Multikey.id);
+	const body = JSON.stringify(await signedActivity.toJsonLd({ contextLoader: mockDocumentLoader }));
+	let response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	assertEquals(processedActivities[0][0], "john");
+	response = await federation.fetch(new Request("https://example.com/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 2);
+	assertEquals(processedActivities[1][0], null);
+	response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 2);
+});
+test("Federation.setInboxListeners().withIdempotency() - global strategy", async () => {
+	const federation = createTestFederation();
+	const processedActivities = [];
+	federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").withIdempotency("global").on(Create, (ctx, activity$1) => {
+		processedActivities.push([ctx.recipient, activity$1]);
+	});
+	const activity = new Create({
+		id: new URL("https://example.com/activities/3"),
+		actor: new URL("https://example.com/person2")
+	});
+	const signedActivity = await signObject(activity, ed25519PrivateKey, ed25519Multikey.id);
+	const body = JSON.stringify(await signedActivity.toJsonLd({ contextLoader: mockDocumentLoader }));
+	let response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	response = await federation.fetch(new Request("https://example.com/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+});
+test("Federation.setInboxListeners().withIdempotency() - custom callback", async () => {
+	const federation = createTestFederation();
+	const processedActivities = [];
+	federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").withIdempotency((ctx, activity) => {
+		if (activity instanceof Follow) return null;
+		const inboxId = ctx.recipient ?? "shared";
+		return `${ctx.origin}:${activity.id?.href}:${inboxId}`;
+	}).on(Create, (ctx, activity) => {
+		processedActivities.push([ctx.recipient, activity]);
+	}).on(Follow, (ctx, activity) => {
+		processedActivities.push([ctx.recipient, activity]);
+	});
+	const createActivity = new Create({
+		id: new URL("https://example.com/activities/4"),
+		actor: new URL("https://example.com/person2")
+	});
+	const signedCreate = await signObject(createActivity, ed25519PrivateKey, ed25519Multikey.id);
+	const createBody = JSON.stringify(await signedCreate.toJsonLd({ contextLoader: mockDocumentLoader }));
+	let response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body: createBody
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body: createBody
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 1);
+	const followActivity = new Follow({
+		id: new URL("https://example.com/activities/5"),
+		actor: new URL("https://example.com/person2")
+	});
+	const signedFollow = await signObject(followActivity, ed25519PrivateKey, ed25519Multikey.id);
+	const followBody = JSON.stringify(await signedFollow.toJsonLd({ contextLoader: mockDocumentLoader }));
+	response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body: followBody
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 2);
+	response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
+		method: "POST",
+		headers: { "Content-Type": "application/activity+json" },
+		body: followBody
+	}), { contextData: void 0 });
+	assertEquals(response.status, 202);
+	assertEquals(processedActivities.length, 3);
+});
+
+//#endregion

package/dist/federation/inbox.test.js

@@ -3,13 +3,13 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { Activity, Create, Invite, Offer, Update } from "../type-B4NJkfVg.js";
+import { Activity, Create, Invite, Offer, Update } from "../type-C69ZBu7f.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
-import "../lookup-CiU3QxQz.js";
-import { InboxListenerSet } from "../inbox-BDdRbWNI.js";
-import { test } from "../testing-ByQmUvf-.js";
-import "../assert_is_error-B035L3om.js";
-import { assertThrows } from "../assert_throws-53_pKeP3.js";
+import "../lookup-pV0JOsuV.js";
+import { InboxListenerSet } from "../inbox-BRru9pX3.js";
+import { test } from "../testing-BWNCAbL-.js";
+import "../assert_is_error-BPGph1Jx.js";
+import { assertThrows } from "../assert_throws-BOO88avQ.js";
 
 //#region src/federation/inbox.test.ts
 test("InboxListenerSet", () => {

package/dist/federation/keycache.test.js

@@ -3,14 +3,14 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { CryptographicKey, Multikey } from "../type-B4NJkfVg.js";
+import { CryptographicKey, Multikey } from "../type-C69ZBu7f.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import { assert } from "../assert-MZs1qjMx.js";
 import { assertInstanceOf } from "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-CRZrzyXm.js";
-import "../lookup-CiU3QxQz.js";
-import { KvKeyCache } from "../keycache-CVBjz3xi.js";
-import { test } from "../testing-ByQmUvf-.js";
+import "../lookup-pV0JOsuV.js";
+import { KvKeyCache } from "../keycache-CN61iGVj.js";
+import { test } from "../testing-BWNCAbL-.js";
 
 //#region src/federation/keycache.test.ts
 test("KvKeyCache.set()", async () => {

package/dist/federation/kv.test.js

@@ -3,18 +3,18 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import "../type-B4NJkfVg.js";
+import "../type-C69ZBu7f.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-CRZrzyXm.js";
-import "../lookup-CiU3QxQz.js";
-import { test } from "../testing-ByQmUvf-.js";
-import "../std__assert-DWivtrGR.js";
-import "../assert_rejects-7UF4R_Qs.js";
-import "../assert_is_error-B035L3om.js";
-import "../assert_not_equals-C80BG-_5.js";
-import "../assert_throws-53_pKeP3.js";
+import "../lookup-pV0JOsuV.js";
+import { test } from "../testing-BWNCAbL-.js";
+import "../std__assert-X-_kMxKM.js";
+import "../assert_rejects-DiIiJbZn.js";
+import "../assert_is_error-BPGph1Jx.js";
+import "../assert_not_equals-f3m3epl3.js";
+import "../assert_throws-BOO88avQ.js";
 
 //#region src/federation/kv.test.ts
 test("MemoryKvStore", async (t) => {

package/dist/federation/middleware.test.js

@@ -3,37 +3,51 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { Activity, Announce, Create, Invite, Multikey, Note, Object as Object$1, Offer, Person, fetchDocumentLoader, getTypeId } from "../type-B4NJkfVg.js";
+import { Activity, Announce, Create, Invite, Multikey, Note, Object as Object$1, Offer, Person, fetchDocumentLoader, getTypeId } from "../type-C69ZBu7f.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import { assert } from "../assert-MZs1qjMx.js";
 import { assertInstanceOf } from "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-CRZrzyXm.js";
-import { ContextImpl, FederationImpl, InboxContextImpl, KvSpecDeterminer, createFederation } from "../middleware-ByPnvMMS.js";
-import "../client-BW4V0OJx.js";
-import { RouterError, lookupObject } from "../lookup-CiU3QxQz.js";
+import { ContextImpl, FederationImpl, InboxContextImpl, KvSpecDeterminer, createFederation } from "../middleware-DY9B2lL8.js";
+import "../client-CnOdwLLN.js";
+import { RouterError, lookupObject } from "../lookup-pV0JOsuV.js";
 import "../types-BSuWJsOm.js";
-import "../actor-DVpsNXhn.js";
-import "../key-CfiBDu3o.js";
-import { signRequest, verifyRequest } from "../http-Cox5GsED.js";
-import { getAuthenticatedDocumentLoader } from "../authdocloader-BkIZCKQv.js";
-import { detachSignature, signJsonLd, verifyJsonLd } from "../ld-CxgmnSO3.js";
-import { doesActorOwnKey } from "../owner-Cxob5_PK.js";
-import { signObject, verifyObject } from "../proof-BiSQNUmQ.js";
-import "../inbox-BDdRbWNI.js";
-import "../builder-E2Icrl_a.js";
+import "../actor-DuCeRiNh.js";
+import "../key-1KXru8Ug.js";
+import { signRequest, verifyRequest } from "../http-BNOYnVsU.js";
+import { getAuthenticatedDocumentLoader } from "../authdocloader-Brax1A32.js";
+import { detachSignature, signJsonLd, verifyJsonLd } from "../ld-Dv8DNNAT.js";
+import { doesActorOwnKey } from "../owner-e3FYDhsk.js";
+import { signObject, verifyObject } from "../proof-6gFMwMNJ.js";
+import "../inbox-BRru9pX3.js";
+import "../builder-CYOcDUkj.js";
 import "../collection-CcnIw1qY.js";
-import "../keycache-CVBjz3xi.js";
-import "../retry-CfF8Gn4d.js";
-import "../send-DSEhWIYD.js";
-import { mockDocumentLoader, test } from "../testing-ByQmUvf-.js";
-import { assertStrictEquals } from "../std__assert-DWivtrGR.js";
-import { assertFalse, assertRejects } from "../assert_rejects-7UF4R_Qs.js";
-import "../assert_is_error-B035L3om.js";
-import { assertNotEquals } from "../assert_not_equals-C80BG-_5.js";
-import { assertThrows } from "../assert_throws-53_pKeP3.js";
-import { ed25519Multikey, ed25519PrivateKey, ed25519PublicKey, rsaPrivateKey2, rsaPrivateKey3, rsaPublicKey2, rsaPublicKey3 } from "../keys-CBKbYaJA.js";
-import { esm_default } from "../esm-mtx3XJAD.js";
+import "../keycache-CN61iGVj.js";
+import "../negotiation-5NPJL6zp.js";
+import "../retry-D4GJ670a.js";
+import "../send-Tl9NOnmO.js";
+import { mockDocumentLoader, test } from "../testing-BWNCAbL-.js";
+import { assertStrictEquals } from "../std__assert-X-_kMxKM.js";
+import { assertFalse, assertRejects } from "../assert_rejects-DiIiJbZn.js";
+import "../assert_is_error-BPGph1Jx.js";
+import { assertNotEquals } from "../assert_not_equals-f3m3epl3.js";
+import { assertThrows } from "../assert_throws-BOO88avQ.js";
+import { ed25519Multikey, ed25519PrivateKey, ed25519PublicKey, rsaPrivateKey2, rsaPrivateKey3, rsaPublicKey2, rsaPublicKey3 } from "../keys-BPdFKgiy.js";
+import { esm_default } from "../esm-DnIzfEj0.js";
 
+//#region src/testing/fixtures/example.com/create.json
+var __context$2 = "https://www.w3.org/ns/activitystreams";
+var type$2 = "Create";
+var id$2 = "https://example.com/create";
+var actor = "https://example.com/person";
+var create_default = {
+	"@context": __context$2,
+	type: type$2,
+	id: id$2,
+	actor
+};
+
+//#endregion
 //#region src/testing/fixtures/example.com/person.json
 var __context$1 = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"];
 var id$1 = "https://example.com/person";
@@ -680,7 +694,7 @@ test({
 				kv,
 				documentLoaderFactory: () => mockDocumentLoader
 			});
-			const req = new Request("https://example.com/");
+			const req = new Request("https://example.com/", { headers: { "accept": "application/ld+json" } });
 			const ctx = federation.createContext(req, 123);
 			assertEquals(ctx.request, req);
 			assertEquals(ctx.url, new URL("https://example.com/"));
@@ -698,7 +712,7 @@ test({
 			assertEquals(await ctx.getSignedKey(), null);
 			assertEquals(await ctx.getSignedKeyOwner(), null);
 			await assertRejects(() => ctx.getActor("someone"), Error, "No actor dispatcher registered");
-			const signedReq = await signRequest(new Request("https://example.com/"), rsaPrivateKey2, rsaPublicKey2.id);
+			const signedReq = await signRequest(new Request("https://example.com/", { headers: { "accept": "application/ld+json" } }), rsaPrivateKey2, rsaPublicKey2.id);
 			const signedCtx = federation.createContext(signedReq, 456);
 			assertEquals(signedCtx.request, signedReq);
 			assertEquals(signedCtx.url, new URL("https://example.com/"));
@@ -707,7 +721,7 @@ test({
 			assertEquals(await signedCtx.getSignedKeyOwner(), null);
 			assertEquals(await signedCtx.getSignedKey(), rsaPublicKey2);
 			assertEquals(await signedCtx.getSignedKeyOwner(), null);
-			const signedReq2 = await signRequest(new Request("https://example.com/"), rsaPrivateKey3, rsaPublicKey3.id);
+			const signedReq2 = await signRequest(new Request("https://example.com/", { headers: { "accept": "application/ld+json" } }), rsaPrivateKey3, rsaPublicKey3.id);
 			const signedCtx2 = federation.createContext(signedReq2, 456);
 			assertEquals(signedCtx2.request, signedReq2);
 			assertEquals(signedCtx2.url, new URL("https://example.com/"));
@@ -740,7 +754,7 @@ test({
 		});
 		await t.step("RequestContext.clone()", () => {
 			const federation = createFederation({ kv });
-			const req = new Request("https://example.com/");
+			const req = new Request("https://example.com/", { headers: { "accept": "application/ld+json" } });
 			const ctx = federation.createContext(req, 123);
 			const clone = ctx.clone(456);
 			assertStrictEquals(clone.request, ctx.request);
@@ -756,6 +770,157 @@ test({
 		esm_default.hardReset();
 	}
 });
+test("Federation.fetch()", async (t) => {
+	esm_default.spyGlobal();
+	esm_default.get("https://example.com/key2", {
+		headers: { "Content-Type": "application/activity+json" },
+		body: await rsaPublicKey2.toJsonLd({ contextLoader: mockDocumentLoader })
+	});
+	esm_default.get("begin:https://example.com/person", {
+		headers: { "Content-Type": "application/activity+json" },
+		body: person_default
+	});
+	const createTestContext = () => {
+		const kv = new MemoryKvStore();
+		const inbox = [];
+		const dispatches = [];
+		const federation = createFederation({
+			kv,
+			documentLoaderFactory: () => mockDocumentLoader,
+			authenticatedDocumentLoaderFactory(identity) {
+				const docLoader = getAuthenticatedDocumentLoader(identity);
+				return (url) => {
+					const urlObj = new URL(url);
+					if (urlObj.host === "example.com") return docLoader(url);
+					return mockDocumentLoader(url);
+				};
+			}
+		});
+		federation.setActorDispatcher("/users/{identifier}", (ctx, identifier) => {
+			dispatches.push(identifier);
+			return new Person({
+				id: ctx.getActorUri(identifier),
+				inbox: ctx.getInboxUri(identifier),
+				preferredUsername: identifier
+			});
+		}).setKeyPairsDispatcher(() => {
+			return [{
+				privateKey: rsaPrivateKey2,
+				publicKey: rsaPublicKey2.publicKey
+			}];
+		});
+		federation.setInboxDispatcher("/users/{identifier}/inbox", () => {
+			return { items: [] };
+		});
+		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (_ctx, activity) => {
+			inbox.push(activity.id.toString());
+			return;
+		});
+		return {
+			federation,
+			inbox,
+			dispatches
+		};
+	};
+	await t.step("GET without accepts header", async () => {
+		const { federation, dispatches } = createTestContext();
+		const response = await federation.fetch(new Request("https://example.com/users/actor", { method: "GET" }), { contextData: void 0 });
+		assertEquals(dispatches, []);
+		assertEquals(response.status, 406);
+	});
+	await t.step("POST with application/json", async () => {
+		const { federation, inbox } = createTestContext();
+		const request = await signRequest(new Request("https://example.com/users/json/inbox", {
+			method: "POST",
+			headers: {
+				"Accept": "application/json",
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(create_default)
+		}), rsaPrivateKey2, rsaPublicKey2.id);
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(inbox.length, 1, "Expected one item in the inbox, json");
+		assertEquals(inbox[0], create_default.id);
+	});
+	await t.step("GET with application/json", async () => {
+		const { federation, dispatches } = createTestContext();
+		const response = await federation.fetch(new Request("https://example.com/users/json", {
+			method: "GET",
+			headers: { "Accept": "application/json" }
+		}), { contextData: void 0 });
+		assertEquals(dispatches, ["json"]);
+		assertEquals(response.status, 200);
+	});
+	await t.step("POST with application/ld+json", async () => {
+		const { federation, inbox } = createTestContext();
+		const request = await signRequest(new Request("https://example.com/users/ld/inbox", {
+			method: "POST",
+			headers: {
+				"Accept": "application/ld+json",
+				"Content-Type": "application/activity+json"
+			},
+			body: JSON.stringify(create_default)
+		}), rsaPrivateKey2, rsaPublicKey2.id);
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(inbox.length, 1, "Expected one inbox activity, ld+json");
+		assertEquals(inbox[0], create_default.id);
+	});
+	await t.step("GET with application/ld+json", async () => {
+		const { federation, dispatches } = createTestContext();
+		const request = new Request("https://example.com/users/ld", {
+			method: "GET",
+			headers: { "Accept": "application/ld+json" }
+		});
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(dispatches, ["ld"]);
+		assertEquals(response.status, 200);
+	});
+	await t.step("POST with application/activity+json", async () => {
+		const { federation, inbox } = createTestContext();
+		const request = await signRequest(new Request("https://example.com/users/activity/inbox", {
+			method: "POST",
+			headers: {
+				"Accept": "application/activity+json",
+				"Content-Type": "application/activity+json"
+			},
+			body: JSON.stringify(create_default)
+		}), rsaPrivateKey2, rsaPublicKey2.id);
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(response.status, 202);
+		assertEquals(inbox.length, 1);
+		assertEquals(inbox[0], create_default.id);
+	});
+	await t.step("GET with application/activity+json", async () => {
+		const { federation, dispatches } = createTestContext();
+		const request = new Request("https://example.com/users/activity", {
+			method: "GET",
+			headers: { "Accept": "application/ld+json" }
+		});
+		const response = await federation.fetch(request, { contextData: void 0 });
+		assertEquals(dispatches, ["activity"]);
+		assertEquals(response.status, 200);
+	});
+	await t.step("onNotAcceptable with GET", async () => {
+		const { federation } = createTestContext();
+		let notAcceptableCalled = false;
+		const response = await federation.fetch(new Request("https://example.com/users/html", {
+			method: "GET",
+			headers: { "Accept": "text/html" }
+		}), {
+			contextData: void 0,
+			onNotAcceptable: () => {
+				notAcceptableCalled = true;
+				return new Response("handled by onNotAcceptable", { status: 200 });
+			}
+		});
+		assertEquals(notAcceptableCalled, true);
+		assertEquals(response.status, 200);
+		assertEquals(await response.text(), "handled by onNotAcceptable");
+	});
+	esm_default.hardReset();
+});
 test("Federation.setInboxListeners()", async (t) => {
 	const kv = new MemoryKvStore();
 	esm_default.spyGlobal();
@@ -808,7 +973,10 @@ test("Federation.setInboxListeners()", async (t) => {
 		federation.setInboxListeners("/users/{identifier}/inbox", "/inbox").on(Create, (ctx, create) => {
 			inbox.push([ctx, create]);
 		});
-		let response = await federation.fetch(new Request("https://example.com/inbox", { method: "POST" }), { contextData: void 0 });
+		let response = await federation.fetch(new Request("https://example.com/inbox", {
+			method: "POST",
+			headers: { "accept": "application/ld+json" }
+		}), { contextData: void 0 });
 		assertEquals(inbox, []);
 		assertEquals(response.status, 404);
 		federation.setActorDispatcher("/users/{identifier}", (_, identifier) => identifier === "john" ? new Person({}) : null).setKeyPairsDispatcher(() => [{
@@ -825,23 +993,37 @@ test("Federation.setInboxListeners()", async (t) => {
 		});
 		response = await federation.fetch(new Request("https://example.com/inbox", {
 			method: "POST",
-			body: JSON.stringify(await activity().toJsonLd(options))
+			body: JSON.stringify(await activity().toJsonLd(options)),
+			headers: {
+				"accept": "application/ld+json",
+				"content-type": "application/ld+json"
+			}
 		}), { contextData: void 0 });
 		assertEquals(inbox, []);
 		assertEquals(response.status, 401);
-		response = await federation.fetch(new Request("https://example.com/users/no-one/inbox", { method: "POST" }), { contextData: void 0 });
+		response = await federation.fetch(new Request("https://example.com/users/no-one/inbox", {
+			method: "POST",
+			headers: { "accept": "application/ld+json" }
+		}), { contextData: void 0 });
 		assertEquals(inbox, []);
 		assertEquals(response.status, 404);
 		response = await federation.fetch(new Request("https://example.com/users/john/inbox", {
 			method: "POST",
-			body: JSON.stringify(await activity().toJsonLd(options))
+			body: JSON.stringify(await activity().toJsonLd(options)),
+			headers: {
+				"accept": "application/ld+json",
+				"content-type": "application/ld+json"
+			}
 		}), { contextData: void 0 });
 		assertEquals(inbox, []);
 		assertEquals(response.status, 401);
 		const activityPayload = await activity().toJsonLd(options);
 		let request = new Request("https://example.com/users/john/inbox", {
 			method: "POST",
-			headers: { "Content-Type": "application/activity+json" },
+			headers: {
+				"Content-Type": "application/activity+json",
+				accept: "application/ld+json"
+			},
 			body: JSON.stringify(activityPayload)
 		});
 		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
@@ -858,7 +1040,10 @@ test("Federation.setInboxListeners()", async (t) => {
 		inbox.shift();
 		request = new Request("https://another.host/users/john/inbox", {
 			method: "POST",
-			headers: { "Content-Type": "application/activity+json" },
+			headers: {
+				"Content-Type": "application/activity+json",
+				"accept": "application/ld+json"
+			},
 			body: JSON.stringify(activityPayload)
 		});
 		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
@@ -873,7 +1058,10 @@ test("Federation.setInboxListeners()", async (t) => {
 		inbox.shift();
 		request = new Request("https://example.com/inbox", {
 			method: "POST",
-			headers: { "Content-Type": "application/activity+json" },
+			headers: {
+				"Content-Type": "application/activity+json",
+				"accept": "application/ld+json"
+			},
 			body: JSON.stringify(await activity().toJsonLd(options))
 		});
 		request = await signRequest(request, rsaPrivateKey3, new URL("https://example.com/person2#key3"));
@@ -888,7 +1076,10 @@ test("Federation.setInboxListeners()", async (t) => {
 		inbox.shift();
 		request = new Request("https://example.com/users/john/inbox", {
 			method: "POST",
-			headers: { "Content-Type": "application/activity+json" },
+			headers: {
+				"Content-Type": "application/activity+json",
+				"accept": "application/ld+json"
+			},
 			body: JSON.stringify(await (await signObject(activity(), ed25519PrivateKey, ed25519Multikey.id, options)).toJsonLd(options))
 		});
 		response = await federation.fetch(request, { contextData: void 0 });
@@ -927,7 +1118,10 @@ test("Federation.setInboxListeners()", async (t) => {
 		const activity = new Create({ actor: new URL("https://example.com/person") });
 		let request = new Request("https://example.com/users/john/inbox", {
 			method: "POST",
-			headers: { "Content-Type": "application/activity+json" },
+			headers: {
+				"Content-Type": "application/activity+json",
+				"Accept": "application/activity+json"
+			},
 			body: JSON.stringify(await activity.toJsonLd({ contextLoader: mockDocumentLoader }))
 		});
 		request = await signRequest(request, rsaPrivateKey2, new URL("https://example.com/key2"));
@@ -1243,7 +1437,7 @@ test("ContextImpl.sendActivity()", async (t) => {
 		collectionSyncHeader = cl.request.headers.get("Collection-Synchronization");
 		const options = {
 			async documentLoader(url) {
-				const response = await federation.fetch(new Request(url), { contextData: void 0 });
+				const response = await federation.fetch(new Request(url, { headers: { "accept": "application/ld+json" } }), { contextData: void 0 });
 				if (response.ok) return {
 					contextUrl: null,
 					document: await response.json(),