@fedify/fedify 2.5.0-dev.2446 → 2.5.0-dev.2492

package/dist/federation/inbox-authentication.test.mjs

@@ -0,0 +1,116 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { a as isActorAuthenticated, i as getEmptyAuthenticationEvidence, n as deserializeAuthentication, o as serializeAuthentication, t as createAuthenticationEvidence } from "../inbox-authentication-DflPYlLL.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { parseIri } from "@fedify/vocab-runtime";
+import { test } from "@fedify/fixture";
+//#region src/federation/inbox-authentication.test.ts
+const DID = "did:key:z6MkhVPuyvgG1RkMv67azDqDCDERPXVrUg1i3qchXY5EACE3";
+const OTHER_DID = "did:key:z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2";
+function evidence(overrides) {
+	return createAuthenticationEvidence({
+		...getEmptyAuthenticationEvidence(),
+		verified: true,
+		...overrides
+	});
+}
+function actor(id, mechanism = "httpSignatures") {
+	return {
+		kind: "actor",
+		id: parseIri(id),
+		mechanism,
+		keyId: null
+	};
+}
+test("isActorAuthenticated() uses the effective principals", () => {
+	const alice = new URL("https://example.com/users/alice");
+	const relay = new URL("https://relay.example/actor");
+	const forwarded = evidence({
+		requestSigners: [actor(relay.href)],
+		documentSigners: [actor(alice.href, "linkedDataSignatures")]
+	});
+	assert(isActorAuthenticated(forwarded, alice));
+	assertFalse(isActorAuthenticated(forwarded, relay));
+	const delivered = evidence({ requestSigners: [actor(alice.href)] });
+	assert(isActorAuthenticated(delivered, alice));
+	assertFalse(isActorAuthenticated(delivered, alice, { scope: "document" }));
+	assert(isActorAuthenticated(evidence({ originAuthenticated: [actor(alice.href, "origin")] }), alice));
+	assertFalse(isActorAuthenticated(getEmptyAuthenticationEvidence(), alice));
+	assertFalse(isActorAuthenticated(delivered, new URL("https://example.com/users/alice/")));
+});
+test("isActorAuthenticated() compares portable actors canonically", () => {
+	const portable = parseIri(`ap://${DID}/actor`);
+	const compatible = new URL(`https://gateway.example/.well-known/apgateway/${DID}/actor`);
+	const otherGateway = new URL(`https://other.example/.well-known/apgateway/${DID}/actor`);
+	const byActor = evidence({ requestSigners: [actor(portable.href)] });
+	assert(isActorAuthenticated(byActor, compatible));
+	assert(isActorAuthenticated(byActor, otherGateway));
+	assertFalse(isActorAuthenticated(byActor, parseIri(`ap://${DID}/other`)));
+	const byAuthority = evidence({ documentSigners: [{
+		kind: "portableAuthority",
+		id: new URL(DID),
+		mechanism: "objectIntegrityProofs",
+		keyId: new URL(`${DID}#${DID.slice(8)}`)
+	}] });
+	assert(isActorAuthenticated(byAuthority, portable));
+	assert(isActorAuthenticated(byAuthority, compatible));
+	assertFalse(isActorAuthenticated(byAuthority, parseIri(`ap://${OTHER_DID}/actor`)));
+	assertFalse(isActorAuthenticated(byAuthority, new URL("https://example.com/users/a")));
+	assertFalse(isActorAuthenticated(byActor, new URL("https://gateway.example/.well-known/apgateway/did:bogus")));
+});
+test("serializeAuthentication() round-trips through JSON", () => {
+	const original = evidence({
+		requestSigners: [{
+			kind: "actor",
+			id: new URL("https://example.com/users/alice"),
+			mechanism: "httpSignatures",
+			keyId: new URL("https://example.com/users/alice#main-key")
+		}],
+		documentSigners: [{
+			kind: "portableAuthority",
+			id: new URL(DID),
+			mechanism: "objectIntegrityProofs",
+			keyId: null
+		}]
+	});
+	const expanded = [{ "@id": "https://example.com/activities/1" }];
+	assertEquals(deserializeAuthentication(JSON.parse(JSON.stringify(serializeAuthentication(original))), expanded, null), {
+		...original,
+		expandedActivity: expanded
+	});
+	for (const malformed of [
+		null,
+		{},
+		{
+			...serializeAuthentication(original),
+			verified: "yes"
+		},
+		{
+			...serializeAuthentication(original),
+			documentSigners: null
+		},
+		{
+			...serializeAuthentication(original),
+			requestSigners: [{
+				kind: "server",
+				id: "x",
+				mechanism: "origin"
+			}]
+		},
+		{
+			...serializeAuthentication(original),
+			requestSigners: [{
+				kind: "actor",
+				id: "not a url",
+				mechanism: "httpSignatures",
+				keyId: null
+			}]
+		}
+	]) assertEquals(deserializeAuthentication(malformed, [], null), null);
+});
+//#endregion
+export {};

package/dist/federation/inbox-report.test.mjs

@@ -2,12 +2,12 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
-import { p as signJsonLd } from "../ld-CD2CsPxq.mjs";
-import { o as signObject } from "../proof-Cryb1c70.mjs";
-import { l as signRequest } from "../http-BUJ5SFh6.mjs";
+import { m as signJsonLd } from "../ld-CdvcOEXQ.mjs";
+import { s as signObject } from "../proof-GH7Poos_.mjs";
+import { u as signRequest } from "../http-BoJCMnjY.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation } from "../middleware-CzoWvrdZ.mjs";
-import { r as createFederationBuilder } from "../builder-Da8b9O6v.mjs";
+import { o as createFederation } from "../middleware-CoBLrTKX.mjs";
+import { r as createFederationBuilder } from "../builder-DphK9v7f.mjs";
 import { Create, Person } from "@fedify/vocab";
 import { exportDidKey, parseIri } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/federation/inbox-view.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/inbox-view.test.mjs

@@ -0,0 +1,369 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { a as createSnapshotOnlyLoader, c as expandDocument, f as restoreVerifiedActivityView, i as createReleasableLoader, l as getActorPresence, n as buildVerifiedActivityView, p as serializeContextSnapshot, r as createContextSnapshot, s as deserializeContextSnapshot, t as ContextSnapshotMissError, u as getPropertyValues } from "../inbox-view-D-skypg-.mjs";
+import { getDocumentLoader, preloadedContexts } from "@fedify/vocab-runtime";
+import { test } from "@fedify/fixture";
+//#region src/federation/inbox-view.test.ts
+const AS = "https://www.w3.org/ns/activitystreams";
+const CUSTOM = "https://remote.example/contexts/custom";
+function createMutableLoader() {
+	const loads = [];
+	const preloaded = getDocumentLoader();
+	return {
+		loads,
+		loader: (url, options) => {
+			loads.push(url);
+			if (url === CUSTOM) {
+				const n = loads.filter((u) => u === CUSTOM).length;
+				return Promise.resolve({
+					contextUrl: null,
+					documentUrl: url,
+					document: { "@context": { tgt: {
+						"@id": n % 2 === 1 ? `${AS}#object` : `${AS}#target`,
+						"@type": "@id"
+					} } }
+				});
+			}
+			return preloaded(url, options);
+		}
+	};
+}
+test("createContextSnapshot() memoizes responses for a delivery", async () => {
+	const { loader, loads } = createMutableLoader();
+	const snapshot = createContextSnapshot(loader);
+	const standard = snapshot.loader("standard");
+	const first = await standard(CUSTOM);
+	const second = await standard(CUSTOM);
+	assertEquals(first, second);
+	assertEquals(loads.filter((url) => url === CUSTOM).length, 1);
+	first.document["@context"] = null;
+	assertEquals((await standard(CUSTOM)).document, second.document);
+	assertEquals(snapshot.entries().map((entry) => [entry.policy, entry.url]), [["standard", CUSTOM]]);
+	snapshot.release();
+	await standard(CUSTOM);
+	assertEquals(loads.filter((url) => url === CUSTOM).length, 2);
+});
+test("createContextSnapshot() memoizes failures for a delivery", async () => {
+	let calls = 0;
+	const snapshot = createContextSnapshot((url) => {
+		calls++;
+		return calls === 1 ? Promise.reject(/* @__PURE__ */ new TypeError("fetch failed")) : Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: {}
+		});
+	});
+	const loader = snapshot.loader("standard");
+	await assertRejects(() => loader(CUSTOM), TypeError);
+	await assertRejects(() => loader(CUSTOM), TypeError);
+	assertEquals(calls, 1);
+	assertEquals(snapshot.entries(), []);
+});
+test("createContextSnapshot() records the normalization overrides", async () => {
+	const snapshot = createContextSnapshot(() => Promise.reject(/* @__PURE__ */ new Error("The caller's loader must not be asked.")));
+	await snapshot.loader("normalization")("https://w3id.org/security/v1");
+	assertEquals(snapshot.entries().map((entry) => [entry.policy, entry.url]), [["normalization", "https://w3id.org/security/v1"]]);
+	const [entry] = await serializeContextSnapshot(snapshot.entries());
+	assert("bundled" in entry && entry.bundled);
+});
+test("serializeContextSnapshot() stores only exactly bundled responses by hash", async () => {
+	const bundled = {
+		contextUrl: null,
+		documentUrl: AS,
+		document: preloadedContexts[AS]
+	};
+	const serialized = await serializeContextSnapshot([
+		{
+			policy: "standard",
+			url: AS,
+			response: bundled
+		},
+		{
+			policy: "standard",
+			url: "https://www.w3.org/ns/activitystreams",
+			response: {
+				...bundled,
+				documentUrl: "https://mirror.example/as"
+			}
+		},
+		{
+			policy: "standard",
+			url: AS,
+			response: {
+				...bundled,
+				document: { "@context": {} }
+			}
+		}
+	]);
+	assert("bundled" in serialized[0]);
+	assert("response" in serialized[1]);
+	assert("response" in serialized[2]);
+	const restored = await deserializeContextSnapshot(JSON.parse(JSON.stringify(serialized)));
+	assertEquals(restored[0].response.document, preloadedContexts[AS]);
+	assertEquals(restored[1].response.documentUrl, "https://mirror.example/as");
+	assertEquals(restored[2].response.document, { "@context": {} });
+});
+test("deserializeContextSnapshot() rejects tampered or unknown entries", async () => {
+	const [entry] = await serializeContextSnapshot([{
+		policy: "standard",
+		url: CUSTOM,
+		response: {
+			contextUrl: null,
+			documentUrl: CUSTOM,
+			document: { a: 1 }
+		}
+	}]);
+	await assertRejects(() => deserializeContextSnapshot([{
+		...entry,
+		response: {
+			contextUrl: null,
+			documentUrl: CUSTOM,
+			document: { a: 2 }
+		}
+	}]), ContextSnapshotMissError);
+	await assertRejects(() => deserializeContextSnapshot([{
+		policy: "standard",
+		url: CUSTOM,
+		sha256: entry.sha256,
+		bundled: true
+	}]), ContextSnapshotMissError);
+	await assertRejects(() => deserializeContextSnapshot([{ url: CUSTOM }]), ContextSnapshotMissError);
+	await assertRejects(() => deserializeContextSnapshot("nope"), ContextSnapshotMissError);
+});
+test("createSnapshotOnlyLoader() serves only the snapshot", async () => {
+	const loader = createSnapshotOnlyLoader([{
+		policy: "standard",
+		url: CUSTOM,
+		response: {
+			contextUrl: null,
+			documentUrl: CUSTOM,
+			document: { a: 1 }
+		}
+	}], "standard");
+	assertEquals((await loader(CUSTOM)).document, { a: 1 });
+	await assertRejects(() => loader(AS), ContextSnapshotMissError);
+	const normalization = createSnapshotOnlyLoader([{
+		policy: "standard",
+		url: CUSTOM,
+		response: {
+			contextUrl: null,
+			documentUrl: CUSTOM,
+			document: { a: 1 }
+		}
+	}], "normalization");
+	await assertRejects(() => normalization(CUSTOM), ContextSnapshotMissError);
+});
+test("createReleasableLoader() is strict until released", async () => {
+	const strict = () => Promise.reject(/* @__PURE__ */ new Error("strict"));
+	const fallback = (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: {}
+	});
+	const releasable = createReleasableLoader(strict, fallback, "standard");
+	await assertRejects(() => releasable.loader(CUSTOM), Error, "strict");
+	releasable.release();
+	assertEquals((await releasable.loader(CUSTOM)).document, {});
+});
+test("getActorPresence() counts every declared actor value", async () => {
+	const expand = (actor) => expandDocument({
+		"@context": AS,
+		id: "https://example.com/activities/1",
+		type: "Create",
+		...actor === void 0 ? {} : { actor }
+	}, getDocumentLoader());
+	assertEquals(getActorPresence(await expand()), "absent");
+	assertEquals(getActorPresence(await expand([])), "absent");
+	assertEquals(getActorPresence(await expand({ "@list": [] })), "absent");
+	for (const actor of [
+		"https://example.com/users/alice",
+		{
+			type: "Person",
+			name: "Anonymous"
+		},
+		{ name: "Anonymous" },
+		{ id: "_:b0" },
+		{ "@list": [{ name: "Anonymous" }] }
+	]) assertEquals(getActorPresence(await expand(actor)), "present");
+	assertEquals(getActorPresence([]), "present");
+});
+test("getPropertyValues() unwraps a single list like the decoders", () => {
+	const node = {
+		a: [{ "@list": [{ "@id": "x" }, { "@id": "y" }] }],
+		b: [{ "@id": "x" }, { "@list": [] }]
+	};
+	assertEquals(getPropertyValues(node, "a").length, 2);
+	assertEquals(getPropertyValues(node, "b").length, 2);
+	assertEquals(getPropertyValues(node, "c"), []);
+});
+test("restoreVerifiedActivityView() replays the authenticated interpretation", async () => {
+	const { loader, loads } = createMutableLoader();
+	const document = {
+		"@context": [AS, CUSTOM],
+		id: "https://example.com/activities/1",
+		type: "Create",
+		tgt: "https://example.com/notes/1"
+	};
+	const { view, expanded } = await buildVerifiedActivityView(createContextSnapshot(loader), {
+		policy: "standard",
+		source: "activity",
+		document,
+		baseUrl: null
+	});
+	const queued = JSON.parse(JSON.stringify(view));
+	const loadsBefore = loads.length;
+	const restored = await restoreVerifiedActivityView(queued, { activity: document });
+	assertEquals(loads.length, loadsBefore);
+	assertEquals(restored.expanded, expanded);
+	assertEquals(getPropertyValues(restored.expanded[0], `${AS}#object`).length, 1);
+	await assertRejects(() => restoreVerifiedActivityView({
+		...queued,
+		expandedDigest: "0"
+	}, { activity: document }), ContextSnapshotMissError);
+	await assertRejects(() => restoreVerifiedActivityView(queued, { activity: {
+		...document,
+		tgt: "https://example.com/notes/2"
+	} }), ContextSnapshotMissError);
+	await assertRejects(() => restoreVerifiedActivityView({
+		...queued,
+		source: "normalizedActivity"
+	}, { activity: document }), ContextSnapshotMissError);
+});
+test("restoreVerifiedActivityView() survives changes to unused bundled terms", async () => {
+	const document = {
+		"@context": [AS, "http://joinmastodon.org/ns"],
+		id: "https://example.com/likes/1",
+		type: "Like",
+		object: "https://example.com/notes/1"
+	};
+	const { view, expanded } = await buildVerifiedActivityView(createContextSnapshot(getDocumentLoader()), {
+		policy: "standard",
+		source: "activity",
+		document,
+		baseUrl: null
+	});
+	const mastodon = view.contexts.find((entry) => entry.url === "http://joinmastodon.org/ns");
+	assert(mastodon != null && "bundled" in mastodon);
+	assertEquals((await restoreVerifiedActivityView({
+		...view,
+		contexts: view.contexts.map((entry) => entry === mastodon ? {
+			...entry,
+			sha256: "0".repeat(64)
+		} : entry)
+	}, { activity: document })).expanded, expanded);
+});
+test("buildVerifiedActivityView() keeps only the contexts it uses", async () => {
+	const { loader } = createMutableLoader();
+	const snapshot = createContextSnapshot(loader);
+	await snapshot.loader("standard")("https://w3id.org/security/v1");
+	const { view } = await buildVerifiedActivityView(snapshot, {
+		policy: "standard",
+		source: "activity",
+		document: {
+			"@context": [AS, CUSTOM],
+			id: "https://example.com/activities/1",
+			type: "Create",
+			tgt: "https://example.com/notes/1"
+		},
+		baseUrl: null
+	});
+	assertEquals(view.contexts.map((entry) => entry.url).sort(), [CUSTOM, AS].sort());
+});
+test("createContextSnapshot() keeps contexts out of jsonld.js's shared cache", async () => {
+	let loads = 0;
+	const document = {
+		"@context": [AS, "https://remote.example/contexts/static"],
+		id: "https://example.com/activities/static",
+		type: "Create"
+	};
+	const tagging = (url, options) => {
+		if (url !== "https://remote.example/contexts/static") return getDocumentLoader()(url, options);
+		loads++;
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": { x: "https://example.com/x" } },
+			tag: "static"
+		});
+	};
+	for (let i = 0; i < 2; i++) {
+		const { view } = await buildVerifiedActivityView(createContextSnapshot(tagging), {
+			policy: "standard",
+			source: "activity",
+			document,
+			baseUrl: null
+		});
+		assert(view.contexts.some((entry) => entry.url === "https://remote.example/contexts/static"));
+	}
+	assertEquals(loads, 2);
+});
+test("buildVerifiedActivityView() tells contexts it could not record", async () => {
+	const cached = "https://remote.example/contexts/shared-cache";
+	const preloaded = getDocumentLoader();
+	await expandDocument({
+		"@context": cached,
+		"y": "z"
+	}, (url, options) => url === cached ? Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: { "@context": { y: "https://example.com/y" } },
+		tag: "static"
+	}) : preloaded(url, options));
+	const build = (document) => buildVerifiedActivityView(createContextSnapshot(preloaded), {
+		policy: "standard",
+		source: "activity",
+		document,
+		baseUrl: null
+	});
+	const { replayable, view } = await build({
+		"@context": [AS, cached],
+		id: "https://example.com/activities/cached",
+		type: "Create"
+	});
+	assertEquals(replayable, false);
+	assertFalse(view.contexts.some((entry) => entry.url === cached));
+	assertEquals((await build({
+		"@context": AS,
+		id: "https://example.com/activities/plain",
+		type: "Create"
+	})).replayable, true);
+});
+test("buildVerifiedActivityView() tells contexts linked from a context", async () => {
+	const cached = "https://remote.example/contexts/linked-shared-cache";
+	const linking = "https://remote.example/contexts/linking";
+	const preloaded = getDocumentLoader();
+	await expandDocument({
+		"@context": cached,
+		"w": "z"
+	}, (url, options) => url === cached ? Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: { "@context": { w: "https://example.com/w" } },
+		tag: "static"
+	}) : preloaded(url, options));
+	const { replayable, view } = await buildVerifiedActivityView(createContextSnapshot((url, options) => url === linking ? Promise.resolve({
+		contextUrl: cached,
+		documentUrl: url,
+		document: { "@context": { v: "https://example.com/v" } }
+	}) : preloaded(url, options)), {
+		policy: "standard",
+		source: "activity",
+		document: {
+			"@context": [AS, linking],
+			id: "https://example.com/activities/linked",
+			type: "Create"
+		},
+		baseUrl: null
+	});
+	assert(view.contexts.some((entry) => entry.url === linking));
+	assertFalse(view.contexts.some((entry) => entry.url === cached));
+	assertEquals(replayable, false);
+});
+//#endregion
+export {};

package/dist/federation/inbox.test.mjs

@@ -4,8 +4,8 @@ globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
-import { t as ActivityListenerSet } from "../activity-listener-C-BSbKI7.mjs";
-import { t as actorsHaveSameOrigin } from "../inbox-CHvMaIFX.mjs";
+import { t as ActivityListenerSet } from "../activity-listener-CELFAodc.mjs";
+import { t as actorsHaveSameOrigin } from "../inbox-BjihTKLo.mjs";
 import { Activity, Create, Invite, Offer, Update } from "@fedify/vocab";
 import { parseIri } from "@fedify/vocab-runtime";
 import { test } from "@fedify/fixture";
@@ -67,12 +67,14 @@ test("ActivityListenerSet", () => {
 	assertEquals(listeners.dispatch(activity), null);
 	assertEquals(listeners.dispatchWithClass(offer), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(offer), listenOffer);
 	assertEquals(listeners.dispatchWithClass(invite), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(invite), listenOffer);
 	assertEquals(listeners.dispatch(create), null);
@@ -83,17 +85,20 @@ test("ActivityListenerSet", () => {
 	assertEquals(listeners.dispatch(offer), listenOffer);
 	assertEquals(listeners.dispatchWithClass(offer), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(invite), listenOffer);
 	assertEquals(listeners.dispatchWithClass(invite), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(create), listenCreate);
 	assertEquals(listeners.dispatchWithClass(create), {
 		class: Create,
-		listener: listenCreate
+		listener: listenCreate,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(update), null);
 	const listenActivity = () => {};
@@ -101,27 +106,32 @@ test("ActivityListenerSet", () => {
 	assertEquals(listeners.dispatch(activity), listenActivity);
 	assertEquals(listeners.dispatchWithClass(activity), {
 		class: Activity,
-		listener: listenActivity
+		listener: listenActivity,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(offer), listenOffer);
 	assertEquals(listeners.dispatchWithClass(offer), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(invite), listenOffer);
 	assertEquals(listeners.dispatchWithClass(invite), {
 		class: Offer,
-		listener: listenOffer
+		listener: listenOffer,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(create), listenCreate);
 	assertEquals(listeners.dispatchWithClass(create), {
 		class: Create,
-		listener: listenCreate
+		listener: listenCreate,
+		options: {}
 	});
 	assertEquals(listeners.dispatch(update), listenActivity);
 	assertEquals(listeners.dispatchWithClass(update), {
 		class: Activity,
-		listener: listenActivity
+		listener: listenActivity,
+		options: {}
 	});
 	assertThrows(() => listeners.add(Activity, listenActivity), TypeError, "Listener already set for this type.");
 });

package/dist/federation/metrics.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
-import { _ as recordKeyLookup, a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, m as recordDocumentFetch, p as recordDocumentCache, r as getFederationMetrics, t as classifyFetchError, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "../metrics-D3LHk6Z4.mjs";
+import { _ as recordKeyLookup, a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, m as recordDocumentFetch, p as recordDocumentCache, r as getFederationMetrics, t as classifyFetchError, u as recordCollectionPageItems, v as recordOutboxActivity, x as registerQueueDepthGauge, y as recordOutboxEnqueue } from "../metrics-CpxvUrBz.mjs";
 import { FetchError } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { DataPointType, MeterProvider, MetricReader } from "@opentelemetry/sdk-metrics";