@fedify/fedify 2.5.0-dev.2609 → 2.5.0-dev.2614

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

@@ -7,15 +7,16 @@ 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 "../std__assert-DvMDRPes.mjs";
+import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { m as signJsonLd } from "../ld-CZsMAfOw.mjs";
-import { s as signObject } from "../proof-D6Kb0Qq9.mjs";
-import { m as verifyRequestDetailed, u as signRequest } from "../http-TgeyuTDM.mjs";
+import { m as signJsonLd } from "../ld-C5JOBBFj.mjs";
+import { s as signObject } from "../proof-tAb5_Dq4.mjs";
+import { m as verifyRequestDetailed, u as signRequest } from "../http-DqOXkYbX.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-CIRoIVSU.mjs";
+import { M as observeOutboundBroadcast, _ as coversDelivery, o as createFederation, v as forwardPortableInboxActivity, y as resolvePortableInboxForwardingOptions } from "../middleware-BkRqMGPU.mjs";
 import { Create, CryptographicKey, Follow, Note, Person, Tombstone } from "@fedify/vocab";
 import { exportDidKey, formatIri, parseIri } from "@fedify/vocab-runtime";
-import { mockDocumentLoader, test } from "@fedify/fixture";
+import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { encodeBase64 } from "byte-encodings/base64";
 //#region src/federation/portable-inbox.test.ts
 const did = await exportDidKey(ed25519PublicKey.publicKey);
@@ -1531,5 +1532,429 @@ test("onRequestFinished covers portable ingress and recipient lookup failures",
 		error: failure
 	});
 });
+function replicationResult(events) {
+	assertEquals(events.map((event) => event.stage), ["started", "preparation-finished"]);
+	assertEquals(events.map((event) => event.operation), ["portable-replication", "portable-replication"]);
+	assertEquals(events[0].broadcastId, events[1].broadcastId);
+	const event = events[1];
+	assert(event.stage === "preparation-finished");
+	return event.result;
+}
+test("portable replication observers distinguish disabled, unavailable, and unclaimed work", async (t) => {
+	for (const scenario of [
+		"disabled",
+		"unavailable",
+		"no-targets"
+	]) await t.step(scenario, async () => {
+		const memory = new MemoryKvStore();
+		const kv = scenario === "unavailable" ? {
+			get: (key) => memory.get(key),
+			set: (key, value, options) => memory.set(key, value, options),
+			delete: (key) => memory.delete(key),
+			list: (prefix) => memory.list(prefix)
+		} : memory;
+		const queue = new RecordingQueue();
+		const { federation } = setup({
+			kv,
+			queue,
+			keyPairs: false,
+			gateways: scenario === "no-targets" ? [LOCAL] : [LOCAL, GATEWAY2],
+			options: { portableInboxForwarding: { maxTargets: scenario === "disabled" ? 0 : 10 } }
+		});
+		const events = [];
+		const deliveries = [];
+		const contexts = [];
+		federation.setOutboundObservers({
+			onDelivery(_ctx, event) {
+				deliveries.push(event);
+			},
+			onBroadcast(ctx, event) {
+				contexts.push(ctx);
+				events.push(event);
+			}
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(replicationResult(events), {
+			type: "skipped",
+			reason: scenario === "disabled" ? "forwarding-disabled" : scenario === "unavailable" ? "forwarding-unavailable" : "no-forwarding-targets"
+		});
+		assertEquals(events[0].activity, {});
+		assertEquals(events[1].activity.type, Follow.typeId.href);
+		assert(events[1].activity.id?.startsWith("ap+ef61://"));
+		assert(Object.isFrozen(events[1].activity));
+		assertStrictEquals(contexts[0], contexts[1]);
+		assertEquals(deliveries, []);
+		assertEquals(queue.outbox.length, 0);
+	});
+});
+test("portable replication observers preserve lazy enqueue, unsigned fallback, and failed claims", async (t) => {
+	await t.step("readiness precedes acceptance without delaying earlier handoffs", async () => {
+		const queue = new RecordingQueue();
+		let accept;
+		const acceptance = new Promise((resolve) => {
+			accept = resolve;
+		});
+		queue.enqueue = (message) => {
+			queue.messages.push(message);
+			return queue.messages.length === 1 ? acceptance.then(() => {
+				throw new Error("acceptance unknown");
+			}) : Promise.resolve();
+		};
+		const { federation, reports } = setup({
+			queue,
+			keyPairs: false
+		});
+		const events = [];
+		const deliveries = [];
+		let ready;
+		const prepared = new Promise((resolve) => {
+			ready = resolve;
+		});
+		let release;
+		const observerGate = new Promise((resolve) => {
+			release = resolve;
+		});
+		federation.setOutboundObservers({
+			onDelivery(_ctx, event) {
+				deliveries.push(event);
+			},
+			async onBroadcast(_ctx, event) {
+				events.push(event);
+				if (event.stage === "preparation-finished") {
+					ready();
+					await observerGate;
+				}
+				throw new Error("recorder failed");
+			}
+		});
+		const json = await signedFollow();
+		let settled = false;
+		const pending = federation.fetch(post(inboxUrl(), json), { contextData: void 0 }).finally(() => {
+			settled = true;
+		});
+		await prepared;
+		assertEquals(queue.outbox.length, 1);
+		assertFalse(settled);
+		assertEquals(replicationResult(events), {
+			type: "prepared",
+			preparedFor: "delivery",
+			destinationCount: 2
+		});
+		accept();
+		release();
+		assertEquals((await pending).status, 202);
+		assertEquals(queue.outbox.length, 2);
+		for (const message of queue.outbox) {
+			assertEquals(message.activity, json);
+			assertEquals(message.keys, []);
+			assertFalse("broadcastId" in message);
+			const plan = deliveries.find((event) => event.stage === "planned" && event.destinationInbox === message.inbox);
+			assert(plan);
+			assertEquals(message.outbound, {
+				broadcast: plan.broadcast,
+				deliveryId: plan.deliveryId,
+				destinationInbox: plan.destinationInbox,
+				portableInbox: plan.portableInbox
+			});
+			assertEquals(JSON.parse(JSON.stringify(message.outbound)), message.outbound);
+			assertEquals(structuredClone(message.outbound), message.outbound);
+		}
+		assertEquals(deliveries.filter((event) => event.stage === "planned").length, 2);
+		const handoffs = deliveries.filter((event) => event.stage === "handoff");
+		assertEquals(handoffs.length, 2);
+		assertEquals(handoffs.filter((event) => event.stage === "handoff" && event.result.type === "enqueued").length, 1);
+		assertEquals(handoffs.filter((event) => event.stage === "handoff" && event.result.type === "enqueue-failed" && event.result.acceptance === "unknown").length, 1);
+		for (const event of deliveries) {
+			assertEquals(event.portableInbox, `ap+ef61://${did}/users/alice/inbox`);
+			if (event.stage === "planned") assertEquals(event.mode, "portable-replication");
+		}
+		assertEquals(events.length, 2);
+		const source = events[0].provenance.inboxRequest;
+		assert(source);
+		assertEquals(source.inboxRequestId, reports[0].inboxRequestId);
+		assertEquals(source.requestId, reports[0].requestId);
+		assertEquals(source.context.origin, LOCAL);
+		for (const message of queue.outbox) assertEquals(message.provenance?.inboxRequest, source);
+		for (const event of [...events, ...deliveries]) assertEquals(event.provenance.inboxRequest, source);
+		federation.setOutboundObservers({
+			onDelivery(_ctx, event) {
+				deliveries.push(event);
+			},
+			onBroadcast(_ctx, event) {
+				events.push(event);
+			}
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		assertEquals(replicationResult(events.slice(2)), {
+			type: "skipped",
+			reason: "no-forwarding-targets"
+		});
+		assert(events[0].broadcastId !== events[2].broadcastId);
+		assertEquals(queue.outbox.length, 2);
+	});
+	await t.step("partial claim failure is incomplete planning and preserves ingress acceptance", async () => {
+		const memory = new MemoryKvStore();
+		const cas = memory.cas.bind(memory);
+		const failure = { failed: "second claim" };
+		let claims = 0;
+		memory.cas = (...args) => {
+			if (args[0][1] === "portableInboxForwarding" && ++claims === 2) return Promise.reject(failure);
+			return cas(...args);
+		};
+		const queue = new RecordingQueue();
+		const { federation } = setup({
+			kv: memory,
+			queue,
+			keyPairs: false
+		});
+		const events = [];
+		const deliveries = [];
+		federation.setOutboundObservers({
+			onDelivery(_ctx, event) {
+				deliveries.push(event);
+			},
+			onBroadcast(_ctx, event) {
+				events.push(event);
+			}
+		});
+		assertEquals((await federation.fetch(post(inboxUrl(), await signedFollow()), { contextData: void 0 })).status, 202);
+		assertEquals(replicationResult(events), {
+			type: "failed",
+			failure: {
+				kind: "local",
+				phase: "destination-planning",
+				error: failure
+			},
+			planning: "incomplete",
+			plannedDestinationCount: 1
+		});
+		assertEquals(deliveries.map((event) => event.stage), ["planned"]);
+		assertEquals(queue.outbox.length, 0);
+	});
+	await t.step("a handled key failure prepares unsigned queue messages", async () => {
+		const queue = new RecordingQueue();
+		const parameters = forwardingParameters({
+			outboxQueue: queue,
+			getKeys: () => Promise.reject(/* @__PURE__ */ new Error("no keys"))
+		});
+		const ctx = createFederation({ kv: parameters.kv }).createContext(new URL(LOCAL));
+		const events = [];
+		const deliveries = [];
+		await observeOutboundBroadcast(ctx, {
+			onDelivery(_ctx, event) {
+				deliveries.push(event);
+			},
+			onBroadcast: (_ctx, event) => {
+				events.push(event);
+			}
+		}, (observation) => forwardPortableInboxActivity(parameters, observation), "portable-replication");
+		assertEquals(replicationResult(events), {
+			type: "prepared",
+			preparedFor: "delivery",
+			destinationCount: 1
+		});
+		assertEquals(deliveries.map((event) => event.stage), ["planned", "handoff"]);
+		const accepted = deliveries[1];
+		assert(accepted.stage === "handoff" && accepted.result.type === "enqueued");
+		assertEquals(queue.outbox[0].keys, []);
+		assertStrictEquals(queue.outbox[0].activity, parameters.activity);
+	});
+});
+test("portable replication attempts settle independently after the forwarding deadline", async () => {
+	const [tracerProvider, exporter] = createTestTracerProvider();
+	let release;
+	const gate = new Promise((resolve) => {
+		release = resolve;
+	});
+	let fetched;
+	const fetching = new Promise((resolve) => {
+		fetched = resolve;
+	});
+	let failed;
+	const failureReported = new Promise((resolve) => {
+		failed = resolve;
+	});
+	let succeeded;
+	const successReported = new Promise((resolve) => {
+		succeeded = resolve;
+	});
+	let ended;
+	const concreteSendsEnded = new Promise((resolve) => {
+		ended = resolve;
+	});
+	const exportSpans = exporter.export.bind(exporter);
+	exporter.export = (spans, callback) => {
+		exportSpans(spans, callback);
+		if (exporter.getSpans("activitypub.send_activity").length === 2) ended();
+	};
+	const attempts = [];
+	const submitted = [];
+	esm_default.spyGlobal().post(`begin:${GATEWAY2}/`, (call) => {
+		submitted.push(JSON.parse(String(call.options.body)));
+		return 503;
+	}).post(`begin:${GATEWAY3}/`, async (call) => {
+		submitted.push(JSON.parse(String(call.options.body)));
+		fetched();
+		await gate;
+		return 202;
+	});
+	try {
+		const { federation, reports } = setup({
+			keyPairs: false,
+			options: {
+				allowPrivateAddress: true,
+				tracerProvider,
+				portableInboxForwarding: { deadline: { milliseconds: 0 } }
+			}
+		});
+		let replacements = 0;
+		federation.setOutboundObservers({
+			senderPayload: true,
+			onAttempt(_ctx, report) {
+				attempts.push(report);
+				if (report.outcome.type === "failed") failed();
+				else succeeded();
+				throw new Error("replication observer failure must be isolated");
+			}
+		});
+		const json = await signedFollow();
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		await Promise.all([fetching, failureReported]);
+		assertEquals(attempts.length, 1);
+		assertEquals(attempts[0].outcome.type, "failed");
+		assert(attempts[0].outcome.response.type === "final");
+		assertEquals(attempts[0].outcome.response.metadata.status, 503);
+		assertEquals(attempts[0].httpExchangeCount, 1);
+		federation.setOutboundObservers({ onAttempt() {
+			replacements++;
+		} });
+		release();
+		await Promise.all([successReported, concreteSendsEnded]);
+		assertEquals(attempts.length, 2);
+		assertEquals(attempts[1].outcome.type, "succeeded");
+		assert(attempts[1].outcome.response.type === "final");
+		assertEquals(attempts[1].outcome.response.metadata.status, 202);
+		assertEquals(attempts[1].httpExchangeCount, 1);
+		assertEquals(replacements, 0);
+		assert(attempts[0].attemptId !== attempts[1].attemptId);
+		assert(attempts[0].deliveryId !== attempts[1].deliveryId);
+		assertEquals(attempts[0].broadcast, attempts[1].broadcast);
+		for (const report of attempts) {
+			assertEquals(report.senderPayload.stage, "sender-payload");
+			if (report.senderPayload.type === "unavailable") assertEquals(report.senderPayload.reason, "privacy-filter-unavailable");
+			else {
+				assertEquals(report.senderPayload.representation, "privacy-projection");
+				assert(Object.isFrozen(report.senderPayload.value));
+			}
+			assertEquals(report.destinationInbox, report.inboxUrl);
+			assertEquals(report.portableInbox, `ap+ef61://${did}/users/alice/inbox`);
+			assertEquals(report.provenance.inboxRequest?.inboxRequestId, reports[0].inboxRequestId);
+			assert(report.provenance.inboxRequest);
+			const span = exporter.spans.find((span) => span.spanContext().spanId === report.trace?.spanId);
+			assert(span);
+			assertEquals(span.name, "activitypub.send_activity");
+		}
+		assertEquals(submitted, [json, json]);
+		assertEquals((await federation.fetch(post(inboxUrl(), json), { contextData: void 0 })).status, 202);
+		assertEquals(submitted.length, 2);
+		assertEquals(replacements, 0);
+	} finally {
+		release();
+		esm_default.hardReset();
+		await tracerProvider.shutdown();
+	}
+});
+test("portable replication observers retain preparation after the forwarding deadline", async (t) => {
+	for (const failed of [false, true]) await t.step(failed ? "late preparation failure" : "late unsigned readiness", async () => {
+		let release;
+		const keyGate = new Promise((resolve) => {
+			release = resolve;
+		});
+		const [tracerProvider, exporter] = createTestTracerProvider();
+		let ended;
+		const concreteSendEnded = new Promise((resolve) => {
+			ended = resolve;
+		});
+		const exportSpans = exporter.export.bind(exporter);
+		exporter.export = (spans, callback) => {
+			exportSpans(spans, callback);
+			if (spans.some((span) => span.name === "activitypub.send_activity")) ended();
+		};
+		const failure = { failed: "late local preparation" };
+		const parameters = forwardingParameters({
+			tracerProvider,
+			options: resolvePortableInboxForwardingOptions({ deadline: { milliseconds: 0 } }),
+			getKeys: async () => {
+				await keyGate;
+				if (failed) Object.defineProperty(parameters.activityId, "href", { get() {
+					throw failure;
+				} });
+				return [];
+			}
+		});
+		const ctx = createFederation({ kv: parameters.kv }).createContext(new URL(LOCAL));
+		const events = [];
+		const deliveries = [];
+		let finished;
+		const preparation = new Promise((resolve) => {
+			finished = resolve;
+		});
+		let fetched;
+		const fetching = new Promise((resolve) => {
+			fetched = resolve;
+		});
+		esm_default.spyGlobal().post(`begin:${GATEWAY2}/`, () => {
+			fetched();
+			return new Response(null, { status: 503 });
+		});
+		try {
+			assertEquals((await observeOutboundBroadcast(ctx, {
+				onDelivery(_ctx, event) {
+					deliveries.push(event);
+				},
+				onBroadcast: (_ctx, event) => {
+					events.push(event);
+					if (event.stage === "preparation-finished") finished();
+				}
+			}, (observation) => forwardPortableInboxActivity(parameters, observation), "portable-replication")).length, 1);
+			assertEquals(events.map((event) => event.stage), ["started"]);
+			release();
+			await preparation;
+			assertEquals(deliveries.map((event) => event.stage), ["planned", failed ? "preparation-failed" : "handoff"]);
+			assertEquals(deliveries[0].deliveryId, deliveries[1].deliveryId);
+			if (failed) {
+				const failedDelivery = deliveries[1];
+				assert(failedDelivery.stage === "preparation-failed");
+				assertStrictEquals(failedDelivery.failure.error, failure);
+				assertEquals(replicationResult(events), {
+					type: "failed",
+					failure: {
+						kind: "local",
+						phase: "request-preparation",
+						error: failure
+					},
+					planning: "complete",
+					plannedDestinationCount: 1
+				});
+				assertEquals(esm_default.callHistory.calls().length, 0);
+			} else {
+				assertEquals(replicationResult(events), {
+					type: "prepared",
+					preparedFor: "delivery",
+					destinationCount: 1
+				});
+				await fetching;
+				await concreteSendEnded;
+				await new Promise((resolve) => setTimeout(resolve, 0));
+				assertEquals(events.length, 2);
+				assertEquals(await forwardPortableInboxActivity(parameters), []);
+			}
+		} finally {
+			release();
+			esm_default.hardReset();
+			await tracerProvider.shutdown();
+		}
+	});
+});
 //#endregion
 export {};

package/dist/federation/portable-parse-uri.test.mjs

@@ -7,7 +7,7 @@ import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation } from "../middleware-CIRoIVSU.mjs";
+import { o as createFederation } from "../middleware-BkRqMGPU.mjs";
 import { Note, Object as Object$1, Person } from "@fedify/vocab";
 import { exportDidKey, parseIri } from "@fedify/vocab-runtime";
 import { test } from "@fedify/fixture";

package/dist/federation/portable-route-activity.test.mjs

@@ -6,9 +6,9 @@ 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 { s as signObject } from "../proof-D6Kb0Qq9.mjs";
+import { s as signObject } from "../proof-tAb5_Dq4.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation } from "../middleware-CIRoIVSU.mjs";
+import { o as createFederation } from "../middleware-BkRqMGPU.mjs";
 import { Create, Note } from "@fedify/vocab";
 import { exportDidKey, formatIri, parseIri, toCompatibleEf61Id } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/federation/portable.test.mjs

@@ -8,10 +8,10 @@ import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { d as verifyPortableObjectProof, s as signObject } from "../proof-D6Kb0Qq9.mjs";
-import { u as signRequest } from "../http-TgeyuTDM.mjs";
+import { d as verifyPortableObjectProof, s as signObject } from "../proof-tAb5_Dq4.mjs";
+import { u as signRequest } from "../http-DqOXkYbX.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-CIRoIVSU.mjs";
+import { b as PORTABLE_OBJECT_CONTENT_TYPE, o as createFederation } from "../middleware-BkRqMGPU.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { Collection, Create, Note, Object as Object$1, PUBLIC_COLLECTION, Person, Tombstone, lookupObject } from "@fedify/vocab";
 import { exportDidKey, formatIri, parseIri, toCompatibleEf61Id } from "@fedify/vocab-runtime";

package/dist/federation/send.test.mjs

@@ -11,10 +11,10 @@ import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { p as verifyRequest } from "../http-TgeyuTDM.mjs";
+import { p as verifyRequest } from "../http-DqOXkYbX.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as doesActorOwnKey } from "../owner-Dwz4fGUW.mjs";
-import { i as sendActivity, n as extractInboxes, r as fetchWithValidatedRedirects, t as SendActivityError } from "../send-BFti0L3I.mjs";
+import { t as doesActorOwnKey } from "../owner-CKlRIkeF.mjs";
+import { i as sendActivity, n as extractInboxes, r as fetchWithValidatedRedirects, t as SendActivityError } from "../send-DzfFREML.mjs";
 import { t as FedifySpanExporter } from "../exporter-DVG68ozH.mjs";
 import { configure, getLogger, reset, withContext } from "@logtape/logtape";
 import { Activity, Application, Endpoints, Group, Person, Service } from "@fedify/vocab";
@@ -1376,5 +1376,46 @@ function recordHops(respond) {
 		}
 	};
 }
+test("sendActivity() bounds a stalled diagnostic preview without changing HTTP failure", async () => {
+	const inbox = new URL("https://example.com/lifecycle/stalled-error");
+	let reads = 0;
+	let cancels = 0;
+	let closed = 0;
+	let submissions = 0;
+	const body = new ReadableStream({
+		pull(controller) {
+			if (reads++ === 0) controller.enqueue(new TextEncoder().encode("partial error"));
+		},
+		cancel() {
+			cancels++;
+			return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	const error = await assertRejects(() => sendActivity({
+		activity: lifecycleActivity,
+		keys: unsignedKeys,
+		inbox
+	}, { openHop: () => Promise.resolve({
+		url: inbox,
+		fetch: () => {
+			submissions++;
+			return Promise.resolve(new Response(body, {
+				status: 503,
+				headers: { "Retry-After": "1" }
+			}));
+		},
+		close: () => {
+			closed++;
+			assertFalse(body.locked);
+			return Promise.resolve();
+		}
+	}) }), SendActivityError);
+	assertEquals(error.statusCode, 503);
+	assertEquals(error.responseBody, "partial error… (timed out)");
+	assertEquals(error.responseHeaders.get("Retry-After"), "1");
+	assertEquals(submissions, 1);
+	assertEquals(cancels, 1);
+	assertEquals(closed, 1);
+});
 //#endregion
 export {};

package/dist/federation/tasks/enqueue.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-IG3pHfvZ.mjs";
 import "../../testing-_9kJHvqh.mjs";
-import { o as createFederation } from "../../middleware-CIRoIVSU.mjs";
+import { o as createFederation } from "../../middleware-BkRqMGPU.mjs";
 import { n as ParallelMessageQueue } from "../../mq-eF96QxUT.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { delay } from "es-toolkit";

package/dist/federation/tasks/tasks.test.mjs

@@ -4,8 +4,8 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../../kv-DCHkaJ9-.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, t as MockQueue } from "../../tasks-IG3pHfvZ.mjs";
 import "../../testing-_9kJHvqh.mjs";
-import { o as createFederation } from "../../middleware-CIRoIVSU.mjs";
-import { r as createFederationBuilder } from "../../builder-BLCvt0zp.mjs";
+import { r as createFederationBuilder } from "../../builder-B2H8GsyI.mjs";
+import { o as createFederation } from "../../middleware-BkRqMGPU.mjs";
 import { t as TaskCodec } from "../../codec-C6rTrpIp.mjs";
 import { t as InProcessMessageQueue } from "../../mq-eF96QxUT.mjs";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";

package/dist/federation/temporal.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { t as hasMalformedKnownTemporalLiteral } from "../temporal-DlYL_raW.mjs";
+import { t as hasMalformedKnownTemporalLiteral } from "../temporal-D9Nt8Fm4.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/temporal.test.ts
 test("hasMalformedKnownTemporalLiteral() detects expanded proof timestamps", async () => {

package/dist/federation/webfinger.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertNotEquals } from "../assert_not_equals-CpPK2t89.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { o as createFederation, s as handleWebFinger } from "../middleware-CIRoIVSU.mjs";
+import { o as createFederation, s as handleWebFinger } from "../middleware-BkRqMGPU.mjs";
 import { Image, Link, Person, Tombstone } from "@fedify/vocab";
 import { parseIri } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, test } from "@fedify/fixture";