@fedify/fedify 2.4.0-dev.1964 → 2.4.0-dev.1995

package/dist/{deno-CtG93ohj.mjs → deno-CABhzCb_.mjs}

@@ -3,6 +3,6 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.1964+1d28dc03";
+var version = "2.4.0-dev.1995+618fd4e7";
 //#endregion
 export { version as n, name as t };

package/dist/{docloader-dk_k3S8d.mjs → docloader-BbGSL0Xq.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { o as validateCryptoKey } from "./key-BVjgbs_9.mjs";
-import { n as doubleKnock } from "./http-D7LX-BL9.mjs";
+import { s as validateCryptoKey } from "./key-Ccs8cnd7.mjs";
+import { n as doubleKnock } from "./http-D9urSO2D.mjs";
 import { getLogger } from "@logtape/logtape";
 import { curry } from "es-toolkit";
 import { UrlError, createActivityPubRequest, getRemoteDocument, logRequest, validatePublicUrl } from "@fedify/vocab-runtime";

package/dist/federation/builder.test.mjs

@@ -6,7 +6,7 @@ import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import { t as assertExists } from "../assert_exists-DtzkXC47.mjs";
 import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
 import "../std__assert-CxFT0MNt.mjs";
-import { r as createFederationBuilder } from "../builder-B4zpKIFU.mjs";
+import { r as createFederationBuilder } from "../builder-D0DxgOV5.mjs";
 import { DisallowedOperatorError, DisallowedVarSpecModifierError, DuplicateRouteVariableError, RouteTemplateOptionsNotMatchedError, RouterError } from "@fedify/uri-template";
 import { Activity, Note, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";

package/dist/federation/handler-compound-proof.test.d.mts

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

package/dist/federation/handler-compound-proof.test.mjs

@@ -0,0 +1,152 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { r as createRequestContext, t as createInboxContext } from "../context-CbS35fLr.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
+import "../std__assert-CxFT0MNt.mjs";
+import { s as signRequest } from "../http-D9urSO2D.mjs";
+import { a as rsaPrivateKey3, c as rsaPublicKey3 } from "../keys-DIJNHW-Y.mjs";
+import { d as handleInbox, o as createFederation } from "../middleware-CzvJvPHK.mjs";
+import { p as signJsonLd } from "../ld-qup__MAW.mjs";
+import { t as ActivityListenerSet } from "../activity-listener-C-BSbKI7.mjs";
+import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
+import { Create } from "@fedify/vocab";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { encodeMultibase } from "@fedify/vocab-runtime";
+import serialize from "json-canon";
+//#region src/federation/handler-compound-proof.test.ts
+async function sha256(value) {
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)));
+}
+async function secureDocument(unsecuredDocument, privateJwk, verificationMethod) {
+	const proofConfiguration = {
+		"@context": unsecuredDocument["@context"],
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod,
+		proofPurpose: "assertionMethod",
+		created: "2023-02-24T23:36:38Z"
+	};
+	const proofHash = await sha256(serialize(proofConfiguration));
+	const documentHash = await sha256(serialize(unsecuredDocument));
+	const input = /* @__PURE__ */ new Uint8Array(64);
+	input.set(proofHash);
+	input.set(documentHash, proofHash.length);
+	const privateKey = await crypto.subtle.importKey("jwk", privateJwk, "Ed25519", false, ["sign"]);
+	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, input));
+	return {
+		...unsecuredDocument,
+		proof: {
+			...proofConfiguration,
+			proofValue: new TextDecoder().decode(encodeMultibase("base58btc", signature))
+		}
+	};
+}
+function requestFor(body) {
+	return new Request("https://example.com/inbox", {
+		method: "POST",
+		body: JSON.stringify(body)
+	});
+}
+async function handle(requestOrBody, dispatched) {
+	const request = requestOrBody instanceof Request ? requestOrBody : requestFor(requestOrBody);
+	const context = createRequestContext({
+		federation: createFederation({ kv: new MemoryKvStore() }),
+		request,
+		url: new URL(request.url),
+		data: void 0,
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	});
+	const inboxListeners = new ActivityListenerSet();
+	inboxListeners.add(Create, () => {
+		if (dispatched != null) dispatched.count++;
+	});
+	return await handleInbox(request, {
+		recipient: null,
+		context,
+		inboxContextFactory() {
+			return createInboxContext({
+				...context,
+				clone: void 0
+			});
+		},
+		kv: new MemoryKvStore(),
+		kvPrefixes: {
+			activityIdempotence: ["_fedify", "activityIdempotence"],
+			publicKey: ["_fedify", "publicKey"],
+			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"]
+		},
+		actorDispatcher() {
+			return null;
+		},
+		inboxListeners,
+		onNotFound() {
+			return new Response("Not found", { status: 404 });
+		},
+		signatureTimeWindow: { minutes: 5 },
+		skipSignatureVerification: false
+	});
+}
+test("handleInbox() enforces portable compound proofs atomically", async () => {
+	const valid = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	assertEquals((await handle(valid)).status, 202);
+	const unsignedInner = structuredClone(map_local_create_note_default.documents.outerUnsecuredDocument);
+	delete unsignedInner.object.proof;
+	const rejected = await handle(await secureDocument(unsignedInner, map_local_create_note_default.keys.outer.testPrivateKeyJwk, map_local_create_note_default.keys.outer.verificationMethod));
+	assertEquals([rejected.status, await rejected.text()], [401, "Failed to verify compound portable Object Integrity Proofs."]);
+	const tamperedInner = structuredClone(map_local_create_note_default.documents.outerUnsecuredDocument);
+	tamperedInner.object.content = "Tampered";
+	assertEquals((await handle(await secureDocument(tamperedInner, map_local_create_note_default.keys.outer.testPrivateKeyJwk, map_local_create_note_default.keys.outer.verificationMethod))).status, 401);
+	const changedAfterSigning = structuredClone(valid);
+	changedAfterSigning.signature = {
+		type: "RsaSignature2017",
+		creator: "https://example.com/keys/1",
+		created: "2023-02-24T23:36:38Z",
+		signatureValue: "not-a-signature"
+	};
+	assertEquals((await handle(changedAfterSigning)).status, 401);
+});
+test("handleInbox() enforces compounds after alternate outer auth", async () => {
+	const createBody = (object) => ({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		id: "https://example.com/activities/compound",
+		type: "Create",
+		actor: rsaPublicKey3.ownerId.href,
+		object
+	});
+	const validInner = structuredClone(map_local_create_note_default.documents.securedInner);
+	const unsignedInner = structuredClone(validInner);
+	delete unsignedInner.proof;
+	for (const authentication of ["http", "ld"]) {
+		const sign = async (body) => {
+			if (authentication === "http") return await signRequest(requestFor(body), rsaPrivateKey3, rsaPublicKey3.id);
+			return requestFor(await signJsonLd(body, rsaPrivateKey3, rsaPublicKey3.id, { contextLoader: mockDocumentLoader }));
+		};
+		const acceptedDispatch = { count: 0 };
+		assertEquals([(await handle(await sign(createBody(structuredClone(validInner))), acceptedDispatch)).status, acceptedDispatch.count], [202, 1]);
+		const rejectedDispatch = { count: 0 };
+		assertEquals([(await handle(await sign(createBody(structuredClone(unsignedInner))), rejectedDispatch)).status, rejectedDispatch.count], [401, 0]);
+	}
+	const proofSetInner = structuredClone(validInner);
+	proofSetInner.proof = [proofSetInner.proof];
+	const unsupportedDispatch = { count: 0 };
+	assertEquals([(await handle(await signRequest(requestFor(createBody(proofSetInner)), rsaPrivateKey3, rsaPublicKey3.id), unsupportedDispatch)).status, unsupportedDispatch.count], [401, 0]);
+});
+test("handleInbox() preserves ordinary top-level proof behavior", async () => {
+	assertEquals((await handle(await secureDocument({
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		id: "https://example.com/activities/ordinary",
+		type: "Create",
+		actor: map_local_create_note_default.keys.outer.controller,
+		object: {
+			id: "https://example.com/notes/ordinary",
+			type: "Note",
+			attributedTo: map_local_create_note_default.keys.outer.controller,
+			content: "An ordinary note"
+		}
+	}, map_local_create_note_default.keys.outer.testPrivateKeyJwk, map_local_create_note_default.keys.outer.verificationMethod))).status, 202);
+});
+//#endregion
+export {};

package/dist/federation/handler.test.mjs

@@ -10,12 +10,14 @@ import "../std__assert-CxFT0MNt.mjs";
 import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
 import { t as assert } from "../assert-CebeUf0C.mjs";
 import { r as parseAcceptSignature } from "../accept-CPVqki78.mjs";
-import { s as signRequest } from "../http-D7LX-BL9.mjs";
+import { a as generateCryptoKeyPair } from "../key-Ccs8cnd7.mjs";
+import { s as signRequest } from "../http-D9urSO2D.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { c as handleActor, d as handleInbox, f as handleObject, h as respondWithObjectIfAcceptable, l as handleCollection, m as respondWithObject, o as createFederation, p as handleOutbox, u as handleCustomCollection } from "../middleware-TeLjzoxn.mjs";
-import { a as compactJsonLd, p as signJsonLd } from "../ld-OuCeQFny.mjs";
+import { c as handleActor, d as handleInbox, f as handleObject, h as respondWithObjectIfAcceptable, l as handleCollection, m as respondWithObject, o as createFederation, p as handleOutbox, u as handleCustomCollection } from "../middleware-CzvJvPHK.mjs";
+import { a as compactJsonLd, p as signJsonLd } from "../ld-qup__MAW.mjs";
+import { r as signObject } from "../proof-BDxNVZ3E.mjs";
 import { t as ActivityListenerSet } from "../activity-listener-C-BSbKI7.mjs";
-import { Activity, Create, Note, Person, Tombstone } from "@fedify/vocab";
+import { Activity, Create, CryptographicKey, Multikey, Note, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError } from "@fedify/vocab-runtime";
 //#region src/federation/handler.test.ts
@@ -4574,5 +4576,121 @@ test("handleInbox() challenge policy enabled + unverifiedActivityHandler throws
 	assertEquals(response.headers.get("Cache-Control"), "no-store", "Cache-Control: no-store must be set for challenge-response");
 	assertEquals(response.headers.get("Vary"), "Accept, Signature", "Vary header must include Accept and Signature");
 });
+test("handleInbox() rejects forged key ownership", async () => {
+	const impersonated = "https://example.com/person2";
+	const attackerKeyId = new URL("https://attacker.example/key");
+	const attackerMultikeyId = new URL("https://attacker.example/multikey");
+	const { privateKey, publicKey } = await generateCryptoKeyPair("RSASSA-PKCS1-v1_5");
+	const forgedKeyDocument = await new CryptographicKey({
+		id: attackerKeyId,
+		owner: new URL(impersonated),
+		publicKey
+	}).toJsonLd({ contextLoader: mockDocumentLoader });
+	const ed25519 = await generateCryptoKeyPair("Ed25519");
+	const forgedMultikeyDocument = await new Multikey({
+		id: attackerMultikeyId,
+		controller: new URL(impersonated),
+		publicKey: ed25519.publicKey
+	}).toJsonLd({ contextLoader: mockDocumentLoader });
+	const documentLoader = (resource) => {
+		if (resource === attackerKeyId.href) return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: forgedKeyDocument
+		});
+		if (resource === attackerMultikeyId.href) return Promise.resolve({
+			contextUrl: null,
+			documentUrl: resource,
+			document: forgedMultikeyDocument
+		});
+		return mockDocumentLoader(resource);
+	};
+	const federation = createFederation({ kv: new MemoryKvStore() });
+	const inboxOptions = {
+		kv: new MemoryKvStore(),
+		kvPrefixes: {
+			activityIdempotence: ["_fedify", "activityIdempotence"],
+			publicKey: ["_fedify", "publicKey"],
+			acceptSignatureNonce: ["_fedify", "acceptSignatureNonce"]
+		},
+		actorDispatcher: ((_ctx, identifier) => identifier === "someone" ? new Person({ name: "Someone" }) : null),
+		inboxListeners: new ActivityListenerSet(),
+		onNotFound: () => new Response("Not found", { status: 404 }),
+		signatureTimeWindow: { minutes: 5 },
+		skipSignatureVerification: false
+	};
+	const handle = async (request) => {
+		const context = createRequestContext({
+			federation,
+			request,
+			url: new URL(request.url),
+			data: void 0,
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		return await handleInbox(request, {
+			recipient: null,
+			context,
+			inboxContextFactory(_activity) {
+				return createInboxContext({
+					...context,
+					clone: void 0
+				});
+			},
+			...inboxOptions
+		});
+	};
+	const activity = {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/identity/v1",
+			"https://w3id.org/security/v1",
+			"https://w3id.org/security/data-integrity/v1"
+		],
+		id: "https://attacker.example/activities/1",
+		type: "Create",
+		actor: impersonated,
+		object: {
+			id: "https://attacker.example/notes/1",
+			type: "Note",
+			attributedTo: impersonated,
+			content: "Hello World!"
+		}
+	};
+	const httpSignedResponse = await handle(await signRequest(new Request("https://example.com/", {
+		method: "POST",
+		body: JSON.stringify(activity)
+	}), privateKey, attackerKeyId));
+	const ldSignedResponse = await handle(new Request("https://example.com/", {
+		method: "POST",
+		body: JSON.stringify(await signJsonLd(activity, privateKey, attackerKeyId, { contextLoader: mockDocumentLoader }))
+	}));
+	const signedObject = await signObject(await Create.fromJsonLd(activity, {
+		documentLoader,
+		contextLoader: mockDocumentLoader
+	}), ed25519.privateKey, attackerMultikeyId, {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		context: ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"]
+	});
+	const proofSignedResponse = await handle(new Request("https://example.com/", {
+		method: "POST",
+		body: JSON.stringify(await signedObject.toJsonLd({
+			format: "compact",
+			contextLoader: mockDocumentLoader,
+			context: ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"]
+		}))
+	}));
+	assertEquals([
+		httpSignedResponse.status,
+		ldSignedResponse.status,
+		proofSignedResponse.status
+	], [
+		401,
+		401,
+		401
+	]);
+	assertEquals(await httpSignedResponse.text(), "Failed to verify the request signature.");
+});
 //#endregion
 export {};

package/dist/federation/idempotency.test.mjs

@@ -5,8 +5,8 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import "../std__assert-CxFT0MNt.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation } from "../middleware-TeLjzoxn.mjs";
-import { r as signObject } from "../proof-D5Ajk4DJ.mjs";
+import { o as createFederation } from "../middleware-CzvJvPHK.mjs";
+import { r as signObject } from "../proof-BDxNVZ3E.mjs";
 import { Create, Follow, Person } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/federation/idempotency.test.ts

package/dist/federation/keycache.test.mjs

@@ -6,7 +6,7 @@ import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import { t as assertInstanceOf } from "../assert_instance_of-g3WcyYNR.mjs";
 import { t as assert } from "../assert-CebeUf0C.mjs";
-import { t as KvKeyCache } from "../keycache-ZLqIfrkL.mjs";
+import { t as KvKeyCache } from "../keycache-BUDHB5rY.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/keycache.test.ts
@@ -14,25 +14,41 @@ test("KvKeyCache.set()", async () => {
 	const kv = new MemoryKvStore();
 	const cache = new KvKeyCache(kv, ["pk"]);
 	await cache.set(new URL("https://example.com/key"), new CryptographicKey({ id: new URL("https://example.com/key") }));
-	assertEquals(await kv.get(["pk", "https://example.com/key"]), {
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/key"
+	]), {
 		"@context": "https://w3id.org/security/v1",
 		id: "https://example.com/key",
 		type: "CryptographicKey"
 	});
 	await cache.set(new URL("https://example.com/key2"), new Multikey({ id: new URL("https://example.com/key2") }));
-	assertEquals(await kv.get(["pk", "https://example.com/key2"]), {
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/key2"
+	]), {
 		"@context": "https://w3id.org/security/multikey/v1",
 		id: "https://example.com/key2",
 		type: "Multikey"
 	});
 	await cache.set(new URL("https://example.com/null"), null);
 	assert(cache.nullKeys.has("https://example.com/null"));
-	assertEquals(await kv.get(["pk", "https://example.com/null"]), null);
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		"https://example.com/null"
+	]), null);
 });
 test("KvKeyCache.get()", async () => {
 	const kv = new MemoryKvStore();
 	const cache = new KvKeyCache(kv, ["pk"]);
-	await kv.set(["pk", "https://example.com/key"], {
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/key"
+	], {
 		"@context": "https://w3id.org/security/v1",
 		id: "https://example.com/key",
 		type: "CryptographicKey"
@@ -40,7 +56,11 @@ test("KvKeyCache.get()", async () => {
 	const cryptoKey = await cache.get(new URL("https://example.com/key"));
 	assertInstanceOf(cryptoKey, CryptographicKey);
 	assertEquals(cryptoKey?.id?.href, "https://example.com/key");
-	await kv.set(["pk", "https://example.com/key2"], {
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/key2"
+	], {
 		"@context": "https://w3id.org/security/multikey/v1",
 		id: "https://example.com/key2",
 		type: "Multikey"
@@ -50,7 +70,11 @@ test("KvKeyCache.get()", async () => {
 	assertEquals(multikey?.id?.href, "https://example.com/key2");
 	cache.nullKeys.set("https://example.com/null", Temporal.Now.instant().add(Temporal.Duration.from({ minutes: 10 })));
 	assertEquals(await cache.get(new URL("https://example.com/null")), null);
-	await kv.set(["pk", "https://example.com/null2"], null);
+	await kv.set([
+		"pk",
+		"2",
+		"https://example.com/null2"
+	], null);
 	assertEquals(await new KvKeyCache(kv, ["pk"]).get(new URL("https://example.com/null2")), null);
 });
 test("KvKeyCache fetch error metadata", async () => {
@@ -105,10 +129,18 @@ test("KvKeyCache cached keys expire after keyTtl", async () => {
 	const cache = new KvKeyCache(kv, ["pk"], { keyTtl: Temporal.Duration.from({ days: 30 }) });
 	const keyId = new URL("https://example.com/key");
 	await cache.set(keyId, new CryptographicKey({ id: keyId }));
-	assert(await kv.get(["pk", keyId.href]) != null);
+	assert(await kv.get([
+		"pk",
+		"2",
+		keyId.href
+	]) != null);
 	assertInstanceOf(await cache.get(keyId), CryptographicKey);
 	kv.advance({ days: 31 });
-	assertEquals(await kv.get(["pk", keyId.href]), void 0);
+	assertEquals(await kv.get([
+		"pk",
+		"2",
+		keyId.href
+	]), void 0);
 	assertEquals(await cache.get(keyId), void 0);
 	assertEquals(cache.nullKeys.has(keyId.href), false);
 	await cache.set(keyId, new CryptographicKey({ id: keyId }));
@@ -116,5 +148,16 @@ test("KvKeyCache cached keys expire after keyTtl", async () => {
 	assertInstanceOf(refetched, CryptographicKey);
 	assertEquals(refetched.id?.href, keyId.href);
 });
+test("KvKeyCache.get() ignores entries from an earlier generation", async () => {
+	const kv = new MemoryKvStore();
+	const cache = new KvKeyCache(kv, ["pk"]);
+	await kv.set(["pk", "https://example.com/key"], {
+		"@context": "https://w3id.org/security/v1",
+		id: "https://example.com/key",
+		owner: "https://example.com/impersonated",
+		type: "CryptographicKey"
+	});
+	assertEquals(await cache.get(new URL("https://example.com/key")), void 0);
+});
 //#endregion
 export {};

package/dist/federation/metrics.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
 import "../std__assert-CxFT0MNt.mjs";
 import { t as assertRejects } from "../assert_rejects-wFbSPn1O.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-B9N27cCB.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-CISXCvB1.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { FetchError } from "@fedify/vocab-runtime";
 import { DataPointType, MeterProvider, MetricReader } from "@opentelemetry/sdk-metrics";