@fedify/fedify 2.5.0-dev.2327 → 2.5.0-dev.2339

package/dist/{builder-D1OTD3--.mjs → builder-4z5McYcY.mjs}

@@ -2,7 +2,7 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { i as getPortableDid, l as isPortableId, n as getCanonicalPortableId } from "./portable-key-id-Ca30-hOa.mjs";
-import { n as version, t as name } from "./deno-CzjcjZ80.mjs";
+import { n as version, t as name } from "./deno-BnX-hlO-.mjs";
 import { t as ActivityListenerSet } from "./activity-listener-C-BSbKI7.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
@@ -91,7 +91,7 @@ var FederationBuilderImpl = class {
 	* specified.
 	*/
 	async build(options) {
-		const { FederationImpl } = await import("./middleware-BURmMr0W.mjs");
+		const { FederationImpl } = await import("./middleware-A02EGx8T.mjs");
 		const f = new FederationImpl(options);
 		const trailingSlashInsensitiveValue = f.router.trailingSlashInsensitive;
 		f.router = this.router.clone();

package/dist/compat/transformers.test.mjs

@@ -5,7 +5,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { O as actorDehydrator, k as autoIdAssigner, n as FederationImpl } from "../middleware-BFr_zLaE.mjs";
+import { O as actorDehydrator, k as autoIdAssigner, n as FederationImpl } from "../middleware-BBSxgV0Y.mjs";
 import { Follow, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/compat/transformers.test.ts

package/dist/{compound-proof-DML23ZA8.mjs → compound-proof-B6xZTnTr.mjs}

@@ -4,8 +4,8 @@ globalThis.addEventListener = () => {};
 import { a as getRawCanonicalPortableId, l as isPortableId, n as getCanonicalPortableId } from "./portable-key-id-Ca30-hOa.mjs";
 import { a as verificationObservation, t as observeAttempt } from "./verification-Dpfcw8ml.mjs";
 import { n as preloadedOnlyDocumentLoader } from "./public-audience--klBIOk1.mjs";
-import { c as getNormalizationContextLoader } from "./ld-BzvgaYZi.mjs";
-import { l as verifyPortableObjectProofPolicy, n as classifyFep2277CoreType, o as verifyMapLocalProof } from "./proof-CImybMS5.mjs";
+import { c as getNormalizationContextLoader } from "./ld-BiFf-T9F.mjs";
+import { l as verifyPortableObjectProofPolicy, n as classifyFep2277CoreType, o as verifyMapLocalProof } from "./proof-vlRUtAdS.mjs";
 import { parseIri, preloadedContexts } from "@fedify/vocab-runtime";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 //#region src/sig/compound-proof.ts

package/dist/{deno-CzjcjZ80.mjs → deno-BnX-hlO-.mjs}

@@ -3,6 +3,6 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.5.0-dev.2327+3a7ba490";
+var version = "2.5.0-dev.2339+5e786861";
 //#endregion
 export { version as n, name as t };

package/dist/{docloader-tMR7o09T.mjs → docloader-_tslGlJv.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { c as validateCryptoKey } from "./key-CfJ7MJmp.mjs";
-import { n as doubleKnock } from "./http-DzBwbsDL.mjs";
+import { c as validateCryptoKey } from "./key-DRLFC1um.mjs";
+import { n as doubleKnock } from "./http-BSmcgoaq.mjs";
 import { getLogger } from "@logtape/logtape";
 import { FetchError, UrlError, createActivityPubRequest, getRemoteDocument, logRequest, resolveDocumentLoaderTimeout, validatePublicUrl, withDocumentLoaderTimeout } from "@fedify/vocab-runtime";
 import { curry } from "es-toolkit";

package/dist/exporter-DThFfe7P.mjs

@@ -0,0 +1,257 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { getLogger } from "@logtape/logtape";
+import { ExportResultCode } from "@opentelemetry/core";
+//#region src/otel/exporter.ts
+/**
+* A SpanExporter that persists ActivityPub activity traces to a
+* {@link KvStore}.  This enables distributed tracing across multiple
+* nodes in a Fedify deployment.
+*
+* The exporter captures activity data from OpenTelemetry span events
+* (`activitypub.activity.received` and `activitypub.activity.sent`)
+* and stores them in the KvStore with trace context preserved.
+*
+* @example Basic usage with MemoryKvStore
+* ```typescript ignore
+* import { MemoryKvStore } from "@fedify/fedify";
+* import { FedifySpanExporter } from "@fedify/fedify/otel";
+* import {
+*   BasicTracerProvider,
+*   SimpleSpanProcessor,
+* } from "@opentelemetry/sdk-trace-base";
+*
+* const kv = new MemoryKvStore();
+* const exporter = new FedifySpanExporter(kv, {
+*   ttl: Temporal.Duration.from({ hours: 1 }),
+* });
+*
+* const provider = new BasicTracerProvider({
+*   spanProcessors: [new SimpleSpanProcessor(exporter)],
+* });
+* ```
+*
+* @example Querying stored traces
+* ```typescript ignore
+* import { MemoryKvStore } from "@fedify/fedify";
+* import { FedifySpanExporter } from "@fedify/fedify/otel";
+*
+* const kv = new MemoryKvStore();
+* const exporter = new FedifySpanExporter(kv);
+* const traceId = "abc123";
+*
+* // Get all activities for a specific trace
+* const activities = await exporter.getActivitiesByTraceId(traceId);
+*
+* // Get recent traces
+* const recentTraces = await exporter.getRecentTraces({ limit: 100 });
+* ```
+*
+* @since 1.10.0
+*/
+var FedifySpanExporter = class {
+	#kv;
+	#ttl;
+	#keyPrefix;
+	/**
+	* Creates a new FedifySpanExporter.
+	*
+	* @param kv The KvStore to persist trace data to.
+	* @param options Configuration options.
+	*/
+	constructor(kv, options) {
+		this.#kv = kv;
+		this.#ttl = options?.ttl;
+		this.#keyPrefix = options?.keyPrefix ?? ["fedify", "traces"];
+	}
+	/**
+	* Exports spans to the KvStore.
+	*
+	* @param spans The spans to export.
+	* @param resultCallback Callback to invoke with the export result.
+	*/
+	export(spans, resultCallback) {
+		this.#exportAsync(spans).then(() => resultCallback({ code: ExportResultCode.SUCCESS })).catch((error) => {
+			getLogger([
+				"fedify",
+				"otel",
+				"exporter"
+			]).error("Failed to export spans to KvStore: {error}", { error });
+			resultCallback({ code: ExportResultCode.FAILED });
+		});
+	}
+	async #exportAsync(spans) {
+		const storeOperations = [];
+		for (const span of spans) {
+			const records = this.#extractRecords(span);
+			for (const record of records) storeOperations.push(this.#storeRecord(record));
+		}
+		const rejected = (await Promise.allSettled(storeOperations)).filter((r) => r.status === "rejected");
+		if (rejected.length > 0) throw new AggregateError(rejected.map((r) => r.reason), "Failed to store one or more trace activity records.");
+	}
+	#extractRecords(span) {
+		const records = [];
+		const spanContext = span.spanContext();
+		const traceId = spanContext.traceId;
+		const spanId = spanContext.spanId;
+		const parentSpanId = span.parentSpanContext?.spanId;
+		for (const event of span.events) if (event.name === "activitypub.activity.received") {
+			const record = this.#extractInboundRecord(event, traceId, spanId, parentSpanId);
+			if (record != null) records.push(record);
+		} else if (event.name === "activitypub.activity.sent") {
+			const record = this.#extractOutboundRecord(event, traceId, spanId, parentSpanId);
+			if (record != null) records.push(record);
+		}
+		return records;
+	}
+	#extractInboundRecord(event, traceId, spanId, parentSpanId) {
+		const attrs = event.attributes;
+		if (attrs == null) return null;
+		const activityJson = attrs["activitypub.activity.json"];
+		if (typeof activityJson !== "string") return null;
+		let activityType = "Unknown";
+		let activityId;
+		let actorId;
+		try {
+			const activity = JSON.parse(activityJson);
+			activityType = activity.type ?? "Unknown";
+			activityId = activity.id;
+			if (typeof activity.actor === "string") actorId = activity.actor;
+			else if (activity.actor != null && typeof activity.actor.id === "string") actorId = activity.actor.id;
+		} catch {}
+		const verified = attrs["activitypub.activity.verified"];
+		const httpSigVerified = attrs["http_signatures.verified"];
+		const httpSigKeyId = attrs["http_signatures.key_id"];
+		const httpSigFailureReason = attrs["http_signatures.failure_reason"];
+		const httpSigKeyFetchStatus = attrs["http_signatures.key_fetch_status"];
+		const httpSigKeyFetchError = attrs["http_signatures.key_fetch_error"];
+		const ldSigVerified = attrs["ld_signatures.verified"];
+		let signatureDetails;
+		if (typeof httpSigVerified === "boolean" || typeof ldSigVerified === "boolean" || typeof httpSigFailureReason === "string") signatureDetails = {
+			httpSignaturesVerified: httpSigVerified === true,
+			httpSignaturesKeyId: typeof httpSigKeyId === "string" && httpSigKeyId !== "" ? httpSigKeyId : void 0,
+			httpSignaturesFailureReason: typeof httpSigFailureReason === "string" && httpSigFailureReason !== "" ? httpSigFailureReason : void 0,
+			httpSignaturesKeyFetchStatus: typeof httpSigKeyFetchStatus === "number" ? httpSigKeyFetchStatus : void 0,
+			httpSignaturesKeyFetchError: typeof httpSigKeyFetchError === "string" && httpSigKeyFetchError !== "" ? httpSigKeyFetchError : void 0,
+			ldSignaturesVerified: ldSigVerified === true
+		};
+		return {
+			traceId,
+			spanId,
+			parentSpanId,
+			direction: "inbound",
+			activityType,
+			activityId,
+			actorId,
+			activityJson,
+			verified: typeof verified === "boolean" ? verified : void 0,
+			signatureDetails,
+			timestamp: (/* @__PURE__ */ new Date(event.time[0] * 1e3 + event.time[1] / 1e6)).toISOString()
+		};
+	}
+	#extractOutboundRecord(event, traceId, spanId, parentSpanId) {
+		const attrs = event.attributes;
+		if (attrs == null) return null;
+		const activityJson = attrs["activitypub.activity.json"];
+		let activityType = "Unknown";
+		let activityId;
+		let actorId;
+		if (typeof activityJson === "string") try {
+			const activity = JSON.parse(activityJson);
+			activityType = activity.type ?? "Unknown";
+			activityId = activity.id;
+			if (typeof activity.actor === "string") actorId = activity.actor;
+			else if (activity.actor != null && typeof activity.actor.id === "string") actorId = activity.actor.id;
+		} catch {}
+		const inboxUrl = attrs["activitypub.inbox.url"];
+		const explicitActivityId = attrs["activitypub.activity.id"];
+		const explicitActivityType = attrs["activitypub.activity.type"];
+		const explicitActorId = attrs["activitypub.actor.id"];
+		return {
+			traceId,
+			spanId,
+			parentSpanId,
+			direction: "outbound",
+			activityType: typeof explicitActivityType === "string" && explicitActivityType !== "" ? explicitActivityType : activityType,
+			activityId: activityId ?? (typeof explicitActivityId === "string" && explicitActivityId !== "" ? explicitActivityId : void 0),
+			actorId: typeof explicitActorId === "string" && explicitActorId !== "" ? explicitActorId : actorId,
+			...typeof activityJson === "string" ? { activityJson } : {},
+			timestamp: (/* @__PURE__ */ new Date(event.time[0] * 1e3 + event.time[1] / 1e6)).toISOString(),
+			inboxUrl: typeof inboxUrl === "string" ? inboxUrl : void 0
+		};
+	}
+	async #storeRecord(record) {
+		const options = this.#ttl != null ? { ttl: this.#ttl } : void 0;
+		const key = [
+			...this.#keyPrefix,
+			record.traceId,
+			record.spanId
+		];
+		await this.#kv.set(key, record, options);
+		await this.#updateTraceSummary(record, options);
+	}
+	async #setWithCasRetry(key, transform, options) {
+		if (this.#kv.cas != null) for (let attempt = 0; attempt < 3; attempt++) {
+			const existing = await this.#kv.get(key);
+			const newValue = transform(existing);
+			if (await this.#kv.cas(key, existing, newValue, options)) return;
+		}
+		const newValue = transform(await this.#kv.get(key));
+		await this.#kv.set(key, newValue, options);
+	}
+	async #updateTraceSummary(record, options) {
+		const summaryKey = [
+			...this.#keyPrefix,
+			"_summaries",
+			record.traceId
+		];
+		await this.#setWithCasRetry(summaryKey, (existing) => {
+			const activityCount = existing != null ? existing.activityCount + 1 : 1;
+			const activityTypes = existing != null ? existing.activityTypes.includes(record.activityType) ? existing.activityTypes : [...existing.activityTypes, record.activityType] : [record.activityType];
+			return {
+				traceId: existing?.traceId ?? record.traceId,
+				timestamp: existing?.timestamp ?? record.timestamp,
+				activityCount,
+				activityTypes
+			};
+		}, options);
+	}
+	/**
+	* Gets all activity records for a specific trace ID.
+	*
+	* @param traceId The trace ID to query.
+	* @returns An array of activity records belonging to the trace.
+	*/
+	async getActivitiesByTraceId(traceId) {
+		const prefix = [...this.#keyPrefix, traceId];
+		const records = [];
+		for await (const entry of this.#kv.list(prefix)) records.push(entry.value);
+		return records;
+	}
+	/**
+	* Gets recent traces with summary information.
+	*
+	* @param options Options for the query.
+	* @returns An array of trace summaries.
+	*/
+	async getRecentTraces(options) {
+		const summaryPrefix = [...this.#keyPrefix, "_summaries"];
+		const summaries = [];
+		for await (const entry of this.#kv.list(summaryPrefix)) summaries.push(entry.value);
+		summaries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+		if (options?.limit != null) return summaries.slice(0, options.limit);
+		return summaries;
+	}
+	/**
+	* Forces the exporter to flush any buffered data.
+	* This is a no-op because we write directly to the KvStore without buffering.
+	*/
+	async forceFlush() {}
+	/**
+	* Shuts down the exporter.
+	*/
+	async shutdown() {}
+};
+//#endregion
+export { FedifySpanExporter as t };

package/dist/federation/builder.test.mjs

@@ -7,7 +7,7 @@ import { t as assertExists } from "../assert_exists-cffSpJ7X.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 { r as createFederationBuilder } from "../builder-D1OTD3--.mjs";
+import { r as createFederationBuilder } from "../builder-4z5McYcY.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/compound-fanout.test.mjs

@@ -6,11 +6,11 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { n as exportJwk } from "../key-CfJ7MJmp.mjs";
+import { n as exportJwk } from "../key-DRLFC1um.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
-import { a as signObject, d as verifyProof } from "../proof-CImybMS5.mjs";
+import { a as signObject, d as verifyProof } from "../proof-vlRUtAdS.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as FederationImpl } from "../middleware-BFr_zLaE.mjs";
+import { n as FederationImpl } from "../middleware-BBSxgV0Y.mjs";
 import { Create, DataIntegrityProof, Note } from "@fedify/vocab";
 import { exportDidKey, parseIri } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

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

@@ -5,10 +5,10 @@ import { r as createRequestContext, t as createInboxContext } from "../context-8
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { a as compactJsonLd, m as verifyCompactJsonLd, p as signJsonLd } from "../ld-BzvgaYZi.mjs";
-import { l as signRequest } from "../http-DzBwbsDL.mjs";
+import { a as compactJsonLd, m as verifyCompactJsonLd, p as signJsonLd } from "../ld-BiFf-T9F.mjs";
+import { l as signRequest } from "../http-BSmcgoaq.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { f as handleInbox, o as createFederation } from "../middleware-BFr_zLaE.mjs";
+import { f as handleInbox, o as createFederation } from "../middleware-BBSxgV0Y.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, CryptographicKey, Multikey, Person, Update } from "@fedify/vocab";

package/dist/federation/handler.test.mjs

@@ -6,20 +6,24 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
 import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+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 { r as parseAcceptSignature } from "../accept-CPVqki78.mjs";
-import { o as generateCryptoKeyPair } from "../key-CfJ7MJmp.mjs";
-import { a as compactJsonLd, p as signJsonLd } from "../ld-BzvgaYZi.mjs";
-import { a as signObject } from "../proof-CImybMS5.mjs";
-import { l as signRequest } from "../http-DzBwbsDL.mjs";
+import { o as generateCryptoKeyPair } from "../key-DRLFC1um.mjs";
+import { a as compactJsonLd, p as signJsonLd } from "../ld-BiFf-T9F.mjs";
+import { a as signObject } from "../proof-vlRUtAdS.mjs";
+import { l as signRequest } from "../http-BSmcgoaq.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { d as handleCustomCollection, f as handleInbox, g as respondWithObjectIfAcceptable, h as respondWithObject, l as handleActor, m as handleOutbox, o as createFederation, p as handleObject, u as handleCollection } from "../middleware-BFr_zLaE.mjs";
+import { d as handleCustomCollection, f as handleInbox, g as respondWithObjectIfAcceptable, h as respondWithObject, l as handleActor, m as handleOutbox, o as createFederation, p as handleObject, u as handleCollection } from "../middleware-BBSxgV0Y.mjs";
 import { t as ActivityListenerSet } from "../activity-listener-C-BSbKI7.mjs";
+import { t as FedifySpanExporter } from "../exporter-DThFfe7P.mjs";
+import { configure, getLogger, reset, withContext } from "@logtape/logtape";
 import { Activity, Create, CryptographicKey, Multikey, Note, Person, Tombstone } from "@fedify/vocab";
 import { FetchError, parseIri } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/federation/handler.test.ts
 const QUOTE_CONTEXT_TERMS = {
 	QuoteAuthorization: "https://w3id.org/fep/044f#QuoteAuthorization",
@@ -3879,6 +3883,221 @@ test("handleInbox() records OpenTelemetry span events", async () => {
 	assertGreaterOrEqual(durations[0].value, 0);
 	assertEquals(durations[0].attributes["activitypub.activity.type"], "https://www.w3.org/ns/activitystreams#Create");
 });
+test("handleInbox() aligns the LogTape context with its own span", async (t) => {
+	async function buildSignedRequest(activityId, noteId) {
+		const activity = new Create({
+			id: new URL(activityId),
+			actor: new URL("https://example.com/users/someone"),
+			object: new Note({
+				id: new URL(noteId),
+				content: "Hello, world!"
+			})
+		});
+		return await signRequest(new Request("https://example.com/users/someone/inbox", {
+			method: "POST",
+			headers: { "Content-Type": "application/activity+json" },
+			body: JSON.stringify(await activity.toJsonLd())
+		}), rsaPrivateKey3, new URL("https://example.com/users/someone#main-key"));
+	}
+	const actorDispatcher = (ctx, identifier) => {
+		if (identifier !== "someone") return null;
+		return new Person({
+			id: ctx.getActorUri(identifier),
+			name: "Someone",
+			inbox: new URL("https://example.com/users/someone/inbox"),
+			publicKey: rsaPublicKey2
+		});
+	};
+	async function callHandleInbox(federation, kv, tracerProvider, listeners, signed) {
+		const context = createRequestContext({
+			federation,
+			request: signed,
+			url: new URL(signed.url),
+			data: void 0,
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			getActorUri(identifier) {
+				return new URL(`https://example.com/users/${identifier}`);
+			}
+		});
+		return await handleInbox(signed, {
+			recipient: "someone",
+			context,
+			inboxContextFactory(_activity) {
+				return createInboxContext({
+					...context,
+					clone: void 0
+				});
+			},
+			kv,
+			kvPrefixes: {
+				activityIdempotence: ["activityIdempotence"],
+				publicKey: ["publicKey"],
+				acceptSignatureNonce: ["acceptSignatureNonce"]
+			},
+			actorDispatcher,
+			inboxListeners: listeners,
+			inboxErrorHandler: void 0,
+			onNotFound: (_request) => new Response("Not found", { status: 404 }),
+			signatureTimeWindow: false,
+			skipSignatureVerification: true,
+			tracerProvider
+		});
+	}
+	const records = [];
+	await reset();
+	try {
+		await configure({
+			sinks: { buffer: (record) => records.push(record) },
+			filters: {},
+			loggers: [{
+				category: [],
+				sinks: ["buffer"],
+				lowestLevel: "debug"
+			}, {
+				category: ["logtape", "meta"],
+				sinks: []
+			}],
+			contextLocalStorage: new AsyncLocalStorage()
+		});
+		const outerContext = {
+			requestId: "outer-request",
+			traceId: "outer0000000000000000000000sentinel",
+			spanId: "outer00000sentinel"
+		};
+		await t.step("a listener failure log matches the inbox's own TraceActivityRecord, and the outer context is restored afterward", async () => {
+			const [tracerProvider, exporter] = createTestTracerProvider();
+			try {
+				const kv = new MemoryKvStore();
+				const federation = createFederation({
+					kv,
+					tracerProvider
+				});
+				const listeners = new ActivityListenerSet();
+				listeners.add(Create, () => {
+					throw new Error("listener boom");
+				});
+				const signed = await buildSignedRequest("https://example.com/activity/listener-failure", "https://example.com/note/listener-failure");
+				await withContext(outerContext, async () => {
+					assertEquals((await callHandleInbox(federation, kv, tracerProvider, listeners, signed)).status, 500);
+					getLogger([
+						"fedify",
+						"federation",
+						"handler.test"
+					]).info("after handled failure");
+				});
+				const span = exporter.getSpan("activitypub.inbox");
+				assert(span != null);
+				const { traceId, spanId } = span.spanContext();
+				const fedifyExporter = new FedifySpanExporter(new MemoryKvStore());
+				await new Promise((resolve) => {
+					fedifyExporter.export([span], () => resolve());
+				});
+				const [record] = await fedifyExporter.getActivitiesByTraceId(traceId);
+				assert(record != null);
+				assertEquals(record.direction, "inbound");
+				assertEquals(record.spanId, spanId);
+				const failureLog = records.find((r) => String(r.rawMessage).startsWith("Failed to process the incoming activity"));
+				assert(failureLog != null);
+				assertEquals(failureLog.properties.spanId, record.spanId);
+				assertEquals(failureLog.properties.traceId, record.traceId);
+				assertEquals(failureLog.properties.requestId, "outer-request");
+				const afterLog = records.find((r) => r.rawMessage === "after handled failure");
+				assert(afterLog != null);
+				assertEquals(afterLog.properties.requestId, outerContext.requestId);
+				assertEquals(afterLog.properties.traceId, outerContext.traceId);
+				assertEquals(afterLog.properties.spanId, outerContext.spanId);
+			} finally {
+				exporter.clear();
+				records.length = 0;
+			}
+		});
+		await t.step("outer context is restored after successful inbox processing", async () => {
+			const [tracerProvider, exporter] = createTestTracerProvider();
+			try {
+				const kv = new MemoryKvStore();
+				const federation = createFederation({
+					kv,
+					tracerProvider
+				});
+				const listeners = new ActivityListenerSet();
+				let received = null;
+				listeners.add(Create, (_ctx, activity) => {
+					received = activity;
+				});
+				const signed = await buildSignedRequest("https://example.com/activity/listener-success", "https://example.com/note/listener-success");
+				await withContext(outerContext, async () => {
+					assertEquals((await callHandleInbox(federation, kv, tracerProvider, listeners, signed)).status, 202);
+					getLogger([
+						"fedify",
+						"federation",
+						"handler.test"
+					]).info("after success");
+				});
+				assert(received != null);
+				const span = exporter.getSpan("activitypub.inbox");
+				assert(span != null);
+				const { spanId } = span.spanContext();
+				const afterLog = records.find((r) => r.rawMessage === "after success");
+				assert(afterLog != null);
+				assertNotEquals(afterLog.properties.spanId, spanId);
+				assertEquals(afterLog.properties.requestId, outerContext.requestId);
+				assertEquals(afterLog.properties.traceId, outerContext.traceId);
+				assertEquals(afterLog.properties.spanId, outerContext.spanId);
+			} finally {
+				exporter.clear();
+				records.length = 0;
+			}
+		});
+		await t.step("concurrent inbox requests do not leak context into each other", async () => {
+			const [tracerProvider, exporter] = createTestTracerProvider();
+			try {
+				const kv = new MemoryKvStore();
+				const federation = createFederation({
+					kv,
+					tracerProvider
+				});
+				let arrived = 0;
+				let release = () => {};
+				const gate = new Promise((resolve) => {
+					release = resolve;
+				});
+				const listeners = new ActivityListenerSet();
+				listeners.add(Create, async () => {
+					arrived++;
+					if (arrived >= 2) release();
+					await gate;
+					throw new Error("listener boom");
+				});
+				const [signedA, signedB] = await Promise.all([buildSignedRequest("https://example.com/activity/concurrent-a", "https://example.com/note/concurrent-a"), buildSignedRequest("https://example.com/activity/concurrent-b", "https://example.com/note/concurrent-b")]);
+				const [resultA, resultB] = await Promise.allSettled([callHandleInbox(federation, kv, tracerProvider, listeners, signedA).finally(release), callHandleInbox(federation, kv, tracerProvider, listeners, signedB).finally(release)]);
+				assert(resultA.status === "fulfilled");
+				assert(resultB.status === "fulfilled");
+				assertEquals(resultA.value.status, 500);
+				assertEquals(resultB.value.status, 500);
+				const spans = exporter.getSpans("activitypub.inbox");
+				assertEquals(spans.length, 2);
+				const spanA = spans.find((s) => s.attributes["activitypub.activity.id"] === "https://example.com/activity/concurrent-a");
+				const spanB = spans.find((s) => s.attributes["activitypub.activity.id"] === "https://example.com/activity/concurrent-b");
+				assert(spanA != null && spanB != null);
+				assertNotEquals(spanA.spanContext().spanId, spanB.spanContext().spanId);
+				const logA = records.find((r) => r.properties.activityId === "https://example.com/activity/concurrent-a" && String(r.rawMessage).startsWith("Failed to process the incoming activity"));
+				const logB = records.find((r) => r.properties.activityId === "https://example.com/activity/concurrent-b" && String(r.rawMessage).startsWith("Failed to process the incoming activity"));
+				assert(logA != null && logB != null);
+				assertEquals(logA.properties.spanId, spanA.spanContext().spanId);
+				assertEquals(logB.properties.spanId, spanB.spanContext().spanId);
+				assertEquals(logA.properties.traceId, spanA.spanContext().traceId);
+				assertEquals(logB.properties.traceId, spanB.spanContext().traceId);
+				assertNotEquals(logA.properties.spanId, logB.properties.spanId);
+			} finally {
+				exporter.clear();
+				records.length = 0;
+			}
+		});
+	} finally {
+		await reset();
+	}
+});
 test("handleInbox() records fedify.queue.task.enqueued when queued", async () => {
 	const [meterProvider, recorder] = createTestMeterProvider();
 	const kv = new MemoryKvStore();

package/dist/federation/hashlink-media.test.mjs

@@ -10,8 +10,8 @@ import "../std__assert-DvMDRPes.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation, x as parseHashlinkGatewayRequest } from "../middleware-BFr_zLaE.mjs";
-import { r as createFederationBuilder } from "../builder-D1OTD3--.mjs";
+import { o as createFederation, x as parseHashlinkGatewayRequest } from "../middleware-BBSxgV0Y.mjs";
+import { r as createFederationBuilder } from "../builder-4z5McYcY.mjs";
 import { n as RouterError } from "../router-u5O5KCQr.mjs";
 import { Note } from "@fedify/vocab";
 import { computeDigestMultibase, encodeMultibase, exportDidKey } from "@fedify/vocab-runtime";

package/dist/federation/idempotency.test.mjs

@@ -4,9 +4,9 @@ globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
-import { a as signObject } from "../proof-CImybMS5.mjs";
+import { a as signObject } from "../proof-vlRUtAdS.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { o as createFederation } from "../middleware-BFr_zLaE.mjs";
+import { o as createFederation } from "../middleware-BBSxgV0Y.mjs";
 import { Create, Follow, Person } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/federation/idempotency.test.ts

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-BzvgaYZi.mjs";
-import { a as signObject } from "../proof-CImybMS5.mjs";
-import { l as signRequest } from "../http-DzBwbsDL.mjs";
+import { p as signJsonLd } from "../ld-BiFf-T9F.mjs";
+import { a as signObject } from "../proof-vlRUtAdS.mjs";
+import { l as signRequest } from "../http-BSmcgoaq.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-BFr_zLaE.mjs";
-import { r as createFederationBuilder } from "../builder-D1OTD3--.mjs";
+import { o as createFederation } from "../middleware-BBSxgV0Y.mjs";
+import { r as createFederationBuilder } from "../builder-4z5McYcY.mjs";
 import { Create, Person } from "@fedify/vocab";
 import { exportDidKey, parseIri } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";