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

package/dist/testing/mod.d.mts

@@ -5,7 +5,7 @@ import { Router } from "@fedify/uri-template";
 import { Activity, Actor, Collection, CryptographicKey, DataIntegrityProof, Hashtag, Link, LookupObjectOptions, Multikey, Note, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
-import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions, PortableObjectVerifier } from "@fedify/vocab-runtime";
+import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions, PortableObjectVerifier, RemoteDocument } from "@fedify/vocab-runtime";
 import { MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -416,6 +416,35 @@ interface GetKeyOwnerOptions {
   tracerProvider?: TracerProvider;
 }
 //#endregion
+//#region src/federation/activity-listener.d.ts
+/**
+ * Options for an inbox listener.
+ * @since 2.5.0
+ */
+interface InboxListenerOptions {
+  /**
+   * Whether activities that declare no `actor` at all may reach the listener.
+   *
+   * Some protocols identify the requester without an `actor`; for example,
+   * Mastodon sends [FEP-7aa9] `FeatureRequest` activities without one.  When
+   * this is `true`, such an activity is dispatched to the listener if Fedify
+   * authenticated at least one principal for it, i.e., the signer of its
+   * Object Integrity Proofs or Linked Data Signature, or otherwise the signer
+   * of the HTTP request, and its `id`, if any, has the same origin as that
+   * principal.  The listener is then responsible for authorizing the request
+   * with {@link InboxContext.authentication}, e.g., with
+   * `featureInteraction.verifyRequest()` from
+   * `@fedify/interaction-controls`.
+   *
+   * An activity that declares an `actor` is never affected by this option;
+   * its actor must be authenticated as usual.
+   *
+   * [FEP-7aa9]: https://w3id.org/fep/7aa9
+   * @default `false`
+   */
+  readonly allowActorless?: boolean;
+}
+//#endregion
 //#region src/federation/inbox-report.d.ts
 /**
  * A JSON value retained from the incoming request.
@@ -458,6 +487,13 @@ type InboxAuthentication = {
     readonly type: "activityOriginMismatch";
     readonly activityId: URL;
     readonly actorIds: readonly URL[];
+  } | {
+    /**
+     * The activity declares no actor, and no principal was authenticated
+     * for it, although its listener allows activities without an actor.
+     * @since 2.5.0
+     */
+    readonly type: "noAuthenticatedPrincipal";
   };
 } | {
   readonly status: "skipped";
@@ -1311,6 +1347,18 @@ interface MessageQueue {
    * @since 2.4.0
    */
   readonly atomicEnqueueMany?: boolean;
+  /**
+   * The largest message, in bytes, that the backend can hold.  Fedify compares
+   * it with a conservative estimate of a message's serialized size: the
+   * length of its JSON serialization encoded in UTF-8, plus 8 bytes for each
+   * JSON value in it, plus what encoding strings beyond Latin-1 as UTF-16
+   * adds, which also bounds binary serialization formats.  When an
+   * incoming activity would make a larger inbox message, Fedify processes the
+   * activity right away instead of enqueueing it, as if there were no inbox
+   * queue.  When omitted, messages are enqueued regardless of their size.
+   * @since 2.5.0
+   */
+  readonly maxMessageSize?: number;
   /**
    * Enqueues a message in the queue.
    * @param message The message to enqueue.
@@ -1349,6 +1397,176 @@ interface MessageQueue {
   getDepth?(): Promise<MessageQueueDepth>;
 }
 //#endregion
+//#region src/federation/inbox-authentication.d.ts
+/**
+ * A party that Fedify authenticated for an incoming activity, independently
+ * of the activity's declared `actor`.
+ * @since 2.5.0
+ */
+interface InboxPrincipal {
+  /**
+   * What {@link InboxPrincipal.id} is:
+   *
+   *  -  `"actor"`: an actor whose ownership of the verifying key Fedify
+   *     confirmed with the actor's own document.
+   *  -  `"portableAuthority"`: a DID whose verification method made a valid
+   *     Object Integrity Proof.  It authenticates the [FEP-ef61] portable
+   *     actors of that DID, and nothing else.
+   *
+   * [FEP-ef61]: https://w3id.org/fep/ef61
+   */
+  readonly kind: "actor" | "portableAuthority";
+  /** The actor ID, or the DID if {@link kind} is `"portableAuthority"`. */
+  readonly id: URL;
+  /**
+   * How the principal was authenticated:
+   *
+   *  -  `"httpSignatures"`: it signed the HTTP request.
+   *  -  `"linkedDataSignatures"`: it made the Linked Data Signature of the
+   *     activity.
+   *  -  `"objectIntegrityProofs"`: it made an Object Integrity Proof of the
+   *     activity.
+   *  -  `"origin"`: the activity was fetched again from the actor's own web
+   *     origin, which happens only for `Context.routeActivity()`.
+   */
+  readonly mechanism: "httpSignatures" | "linkedDataSignatures" | "objectIntegrityProofs" | "origin";
+  /** The key or verification method that authenticated the principal. */
+  readonly keyId: URL | null;
+}
+/**
+ * Who Fedify authenticated for an incoming activity, and the interpretation of
+ * the activity it authenticated.  Inbox listeners receive it as
+ * {@link InboxContext.authentication}.
+ *
+ * Authenticated principals are independent of the activity's declared
+ * `actor`: an activity forwarded by a relay is signed by the relay in its
+ * HTTP request, but its document may be signed by its author, and some
+ * activities, such as [FEP-7aa9] `FeatureRequest`s sent by Mastodon, declare
+ * no `actor` at all.  A valid signature alone does not authorize anything;
+ * use {@link isActorAuthenticated} to check whether a specific actor was
+ * authenticated.
+ *
+ * [FEP-7aa9]: https://w3id.org/fep/7aa9
+ * @since 2.5.0
+ */
+interface InboxAuthenticationEvidence {
+  /**
+   * Whether signatures were verified at all.  It is `false` only when
+   * signature verification is skipped, or when there is no evidence, e.g.,
+   * for an activity queued by an older version of Fedify.  In that case all
+   * the principal lists are empty.
+   */
+  readonly verified: boolean;
+  /**
+   * The principals that signed the HTTP request, i.e., the server that
+   * delivered the activity, which may have forwarded it.  It is empty when
+   * the activity document was authenticated by its own signatures, so that
+   * HTTP Signatures did not need to be verified.
+   */
+  readonly requestSigners: readonly InboxPrincipal[];
+  /**
+   * The principals that made the verified Linked Data Signature or Object
+   * Integrity Proofs of the activity document.  All of them are listed when
+   * there are several proofs.
+   */
+  readonly documentSigners: readonly InboxPrincipal[];
+  /**
+   * The actors authenticated because `Context.routeActivity()` fetched the
+   * activity again from their own web origin.  It is always empty for
+   * activities delivered to an inbox.
+   */
+  readonly originAuthenticated: readonly InboxPrincipal[];
+  /**
+   * The activity as Fedify interpreted it while authenticating it, in
+   * expanded JSON-LD.  Typed vocabulary objects omit some values, such as
+   * blank node references and values they cannot decode, so authorization
+   * that has to count every value of a property, e.g., that a property has
+   * exactly one value, should inspect this instead.  It is deeply frozen.
+   * It is empty when there is no evidence.
+   */
+  readonly expandedActivity: readonly Record<string, unknown>[];
+  /**
+   * The base URL the activity was decoded with, e.g., the URL an activity
+   * fetched by `Context.routeActivity()` was finally retrieved from, or
+   * `null` if none was given.  Relative IRIs left in
+   * {@link expandedActivity} resolve against it, or against the activity's
+   * own `@id` if it is `null`, as the decoder resolves them.
+   */
+  readonly baseUrl: URL | null;
+}
+/**
+ * A {@link InboxPrincipal} as stored in a queued message.
+ * @internal
+ */
+interface SerializedInboxPrincipal {
+  readonly kind: InboxPrincipal["kind"];
+  readonly id: string;
+  readonly mechanism: InboxPrincipal["mechanism"];
+  readonly keyId: string | null;
+}
+/**
+ * The principals of an {@link InboxAuthenticationEvidence} as stored in
+ * a queued message.  The expanded activity and the base URL are restored
+ * from the queued verified view instead.
+ * @internal
+ */
+interface SerializedInboxAuthentication {
+  readonly verified: boolean;
+  readonly requestSigners: readonly SerializedInboxPrincipal[];
+  readonly documentSigners: readonly SerializedInboxPrincipal[];
+  readonly originAuthenticated: readonly SerializedInboxPrincipal[];
+}
+//#endregion
+//#region src/sig/ld.d.ts
+/**
+ * How a context loader marked by {@link markEffectiveContextLoader} already
+ * resolves contexts.
+ * @internal
+ */
+type EffectiveContextLoaderPolicy = "standard" | "normalization";
+//#endregion
+//#region src/federation/inbox-view.d.ts
+/**
+ * A {@link ContextSnapshotEntry} as stored in a queued message.  A response
+ * that equals the one Fedify bundles for the URL is stored as a reference to
+ * the bundled context, along with its hash for diagnostics.
+ * @internal
+ */
+type SerializedContextSnapshotEntry = {
+  readonly policy: EffectiveContextLoaderPolicy;
+  readonly url: string; /** The SHA-256 of the canonical JSON of the whole response. */
+  readonly sha256: string;
+} & ({
+  readonly bundled: true;
+} | {
+  readonly response: RemoteDocument;
+});
+/**
+ * The interpretation of an incoming activity that Fedify authenticated, as
+ * stored in a queued message.  The document itself is not copied; it is
+ * a field of the message.
+ * @internal
+ */
+interface SerializedVerifiedActivityView {
+  /** The format version. */
+  readonly version: 1;
+  /** The context loader policy the activity was parsed with. */
+  readonly policy: EffectiveContextLoaderPolicy;
+  /**
+   * Which document the activity was parsed from, with its Linked Data
+   * Signature detached: the `activity` of the message, i.e., the payload as
+   * received, or its `normalizedActivity`, i.e., the payload compacted for
+   * Linked Data Signatures.
+   */
+  readonly source: "activity" | "normalizedActivity";
+  /** The `baseUrl` option the activity was parsed with. */
+  readonly baseUrl: string | null;
+  /** The context responses the interpretation used. */
+  readonly contexts: readonly SerializedContextSnapshotEntry[];
+  /** The digest of the expanded activity. */
+  readonly expandedDigest: string;
+}
+//#endregion
 //#region src/federation/retry.d.ts
 /**
  * The context passed to a {@link RetryPolicy} callback.
@@ -1683,6 +1901,21 @@ interface InboxMessage {
    * @internal
    */
   readonly ldSignatureVerified?: boolean;
+  /**
+   * The interpretation of the activity that Fedify authenticated, i.e., which
+   * document it was parsed from and every JSON-LD context response the parse
+   * used, so that the worker and its retries dispatch the very same
+   * interpretation without loading contexts again.  Absent in messages queued
+   * by older Fedify versions.
+   * @internal
+   */
+  readonly verifiedView?: SerializedVerifiedActivityView;
+  /**
+   * Who Fedify authenticated for the activity.  Absent in messages queued by
+   * older Fedify versions.
+   * @internal
+   */
+  readonly authentication?: SerializedInboxAuthentication;
   readonly started: string;
   readonly attempt: number;
   readonly identifier: string | null;
@@ -3034,11 +3267,27 @@ interface InboxListenerSetters<TContextData> {
   /**
    * Registers a listener for a specific incoming activity type.
    *
+   * @example
+   * ``` typescript
+   * federation
+   *   .setInboxListeners("/users/{identifier}/inbox", "/inbox")
+   *   // Mastodon sends FeatureRequest activities without an actor:
+   *   .on(FeatureRequest, async (ctx, request) => {
+   *     const verification = await featureInteraction.verifyRequest(ctx, {
+   *       request,
+   *       authentication: ctx.authentication,
+   *     });
+   *     // ...
+   *   }, { allowActorless: true });
+   * ```
+   *
    * @param type A subclass of {@link Activity} to listen to.
    * @param listener A callback to handle an incoming activity.
+   * @param options Options for the listener.  See
+   *                {@link InboxListenerOptions}.  (Since 2.5.0.)
    * @returns The setters object so that settings can be chained.
    */
-  on<TActivity extends Activity>(type: new (...args: any[]) => TActivity, listener: InboxListener<TContextData, TActivity>): InboxListenerSetters<TContextData>;
+  on<TActivity extends Activity>(type: new (...args: any[]) => TActivity, listener: InboxListener<TContextData, TActivity>, options?: InboxListenerOptions): InboxListenerSetters<TContextData>;
   /**
    * Registers an error handler for inbox listeners.  Any exceptions thrown
    * from the listeners are caught and passed to this handler.
@@ -4566,6 +4815,17 @@ interface InboxContext<TContextData> extends Context<TContextData> {
    * @since 1.2.0
    */
   readonly recipient: string | null;
+  /**
+   * Who Fedify authenticated for the incoming activity, independently of its
+   * declared `actor`, and the interpretation of the activity that was
+   * authenticated.  It is preserved through the inbox queue and its retries.
+   *
+   * Use it with {@link isActorAuthenticated} to authorize requests that do
+   * not declare an `actor`, which reach a listener only if it is registered
+   * with the `allowActorless` option.
+   * @since 2.5.0
+   */
+  readonly authentication: InboxAuthenticationEvidence;
   /**
    * Creates a new context with the same properties as this one,
    * but with the given data.

package/dist/testing/mod.mjs

@@ -2,8 +2,8 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { r as testDefinitions } from "../dist-DJQM4u7i.mjs";
-import { n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-8Tu9kea0.mjs";
+import { n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-COHd1Rsh.mjs";
 import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { a as numberSchema, i as makeSchema, n as baseOptions, o as stringSchema, r as envelopeSchema, t as MockQueue } from "../tasks-IG3pHfvZ.mjs";
-import "../testing-t8xDeJZ5.mjs";
+import "../testing-Dbr21vZk.mjs";
 export { ManualClockKvStore, MockQueue, baseOptions, createInboxContext, createOutboxContext, createRequestContext, envelopeSchema, makeSchema, numberSchema, stringSchema, testDefinitions };

package/dist/{testing-t8xDeJZ5.mjs → testing-Dbr21vZk.mjs}

@@ -2,7 +2,7 @@ import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import "./dist-DJQM4u7i.mjs";
-import "./context-8Tu9kea0.mjs";
+import "./context-COHd1Rsh.mjs";
 import "./kv-DBRWVx3Q.mjs";
 import "./tasks-IG3pHfvZ.mjs";
 export {};

package/dist/utils/docloader.test.mjs

@@ -5,9 +5,9 @@ import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
-import { f as verifyRequest } from "../http-BUJ5SFh6.mjs";
+import { f as verifyRequest } from "../http-BZkyQIkb.mjs";
 import { i as rsaPrivateKey2 } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-B-0nqOB1.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-CpsDyqVN.mjs";
 import { configure, reset } from "@logtape/logtape";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/utils/kv-cache.test.mjs

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as kvCache, t as MockKvStore } from "../kv-cache-D_m3A241.mjs";
+import { n as kvCache, t as MockKvStore } from "../kv-cache-CTQSfkmp.mjs";
 import { preloadedContexts } from "@fedify/vocab-runtime";
 import { deepStrictEqual, throws } from "node:assert";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";

package/dist/utils/mod.cjs

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_kv_cache = require("../kv-cache-kkBB0vbI.cjs");
+const require_kv_cache = require("../kv-cache-CjgCOz3i.cjs");
 exports.getAuthenticatedDocumentLoader = require_kv_cache.getAuthenticatedDocumentLoader;
 exports.kvCache = require_kv_cache.kvCache;

package/dist/utils/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-7015lbrx.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-U7uz5nx4.js";
 export { getAuthenticatedDocumentLoader, kvCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.5.0-dev.2446+2014cb03",
+  "version": "2.5.0-dev.2448+756933d0",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -151,10 +151,10 @@
     "structured-field-values": "^2.0.4",
     "temporal-polyfill": "^1.0.1",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.5.0-dev.2446+2014cb03",
-    "@fedify/vocab-runtime": "2.5.0-dev.2446+2014cb03",
-    "@fedify/vocab": "2.5.0-dev.2446+2014cb03",
-    "@fedify/webfinger": "2.5.0-dev.2446+2014cb03"
+    "@fedify/vocab": "2.5.0-dev.2448+756933d0",
+    "@fedify/webfinger": "2.5.0-dev.2448+756933d0",
+    "@fedify/uri-template": "2.5.0-dev.2448+756933d0",
+    "@fedify/vocab-runtime": "2.5.0-dev.2448+756933d0"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
@@ -166,8 +166,8 @@
     "tsx": "^4.21.0",
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
-    "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-tools": "^2.5.0-dev.2446+2014cb03"
+    "@fedify/vocab-tools": "^2.5.0-dev.2448+756933d0",
+    "@fedify/fixture": "2.0.0"
   },
   "scripts": {
     "build:self": "tsdown",

package/dist/inbox-CHvMaIFX.mjs

@@ -1,188 +0,0 @@
-import { Temporal } from "temporal-polyfill";
-import "urlpattern-polyfill";
-globalThis.addEventListener = () => {};
-import { t as getAuthenticationOrigin } from "./portable-key-id-Ca30-hOa.mjs";
-import { n as version, t as name } from "./deno-eNpfj4oR.mjs";
-import { g as recordInboxActivity, n as getDurationMs, r as getFederationMetrics } from "./metrics-D3LHk6Z4.mjs";
-import { getLogger } from "@logtape/logtape";
-import { getTypeId } from "@fedify/vocab";
-import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
-//#region src/federation/inbox.ts
-/**
-* Checks whether an activity's ID and all of its actor IDs have the same
-* [FEP-fe34] origin.  Activities without an ID have no origin to authenticate.
-*
-* Origins are compared by `getAuthenticationOrigin()`, so a portable activity
-* and its portable actors, including compatible identifiers on any gateway,
-* are compared by their DIDs.  An ID that has no supported origin, such as an
-* opaque URN, never matches.
-*
-* The caller is responsible for rejecting a missing primary actor ID before
-* relying on this check.
-*
-* [FEP-fe34]: https://w3id.org/fep/fe34
-* @internal
-*/
-function actorsHaveSameOrigin(activity) {
-	if (activity.id == null) return true;
-	const origin = getAuthenticationOrigin(activity.id);
-	return origin != null && activity.actorIds.every((actor) => getAuthenticationOrigin(actor) === origin);
-}
-async function routeActivity({ context: ctx, json, originalJson, normalizedActivity, ldSignatureVerified, activity, recipient, inboxListeners, inboxContextFactory, listenerInboxContextFactory, inboxErrorHandler, kv, kvPrefixes, queue, span, meterProvider, tracerProvider, idempotencyStrategy }) {
-	const logger = getLogger([
-		"fedify",
-		"federation",
-		"inbox"
-	]);
-	if (activity.actorId == null) {
-		logger.error("Missing actor.", { activity: json });
-		span.setStatus({
-			code: SpanStatusCode.ERROR,
-			message: "Missing actor."
-		});
-		recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
-		return "missingActor";
-	}
-	let cacheKey = null;
-	if (activity.id != null) {
-		const inboxContext = inboxContextFactory(recipient, json, activity.id?.href, getTypeId(activity).href);
-		const strategy = idempotencyStrategy ?? "per-inbox";
-		let keyString;
-		if (typeof strategy === "function") keyString = await strategy(inboxContext, activity);
-		else switch (strategy) {
-			case "global":
-				keyString = activity.id.href;
-				break;
-			case "per-origin":
-				keyString = `${ctx.origin}\n${activity.id.href}`;
-				break;
-			case "per-inbox":
-				keyString = `${ctx.origin}\n${activity.id.href}\n${recipient == null ? "sharedInbox" : `inbox\n${recipient}`}`;
-				break;
-			default: keyString = `${ctx.origin}\n${activity.id.href}`;
-		}
-		if (keyString != null) cacheKey = [...kvPrefixes.activityIdempotence, keyString];
-	}
-	if (cacheKey != null) {
-		if (await kv.get(cacheKey) === true) {
-			logger.debug("Activity {activityId} has already been processed.", {
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.UNSET,
-				message: `Activity ${activity.id?.href} has already been processed.`
-			});
-			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
-			return "alreadyProcessed";
-		}
-	}
-	span.setAttribute("activitypub.actor.id", activity.actorId.href);
-	if (queue != null) {
-		const carrier = {};
-		propagation.inject(context.active(), carrier);
-		try {
-			await queue.enqueue({
-				type: "inbox",
-				id: crypto.randomUUID(),
-				baseUrl: ctx.origin,
-				activity: originalJson ?? json,
-				...normalizedActivity == null ? {} : { normalizedActivity },
-				...ldSignatureVerified == null ? {} : { ldSignatureVerified },
-				identifier: recipient,
-				attempt: 0,
-				started: (/* @__PURE__ */ new Date()).toISOString(),
-				traceContext: carrier
-			});
-		} catch (error) {
-			logger.error("Failed to enqueue the incoming activity {activityId}:\n{error}", {
-				error,
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: `Failed to enqueue the incoming activity ${activity.id?.href}.`
-			});
-			throw error;
-		}
-		getFederationMetrics(meterProvider).recordQueueTaskEnqueued({
-			role: "inbox",
-			queue,
-			activityType: getTypeId(activity).href
-		}, 0);
-		recordInboxActivity(meterProvider, "queued", getTypeId(activity).href);
-		logger.info("Activity {activityId} is enqueued.", {
-			activityId: activity.id?.href,
-			activity: json,
-			recipient
-		});
-		return "enqueued";
-	}
-	tracerProvider = tracerProvider ?? trace.getTracerProvider();
-	return await tracerProvider.getTracer(name, version).startActiveSpan("activitypub.dispatch_inbox_listener", { kind: SpanKind.INTERNAL }, async (span) => {
-		const dispatched = inboxListeners?.dispatchWithClass(activity);
-		if (dispatched == null) {
-			logger.error("Unsupported activity type:\n{activity}", {
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.UNSET,
-				message: `Unsupported activity type: ${getTypeId(activity).href}`
-			});
-			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
-			span.end();
-			return "unsupportedActivity";
-		}
-		const { class: cls, listener } = dispatched;
-		span.updateName(`activitypub.dispatch_inbox_listener ${cls.name}`);
-		try {
-			const activityType = getTypeId(activity).href;
-			const started = performance.now();
-			try {
-				const contextFactory = listenerInboxContextFactory ?? inboxContextFactory;
-				await listener(contextFactory(recipient, contextFactory === inboxContextFactory ? json : originalJson ?? json, activity.id?.href, activityType), activity);
-			} finally {
-				getFederationMetrics(meterProvider).recordInboxProcessingDuration(activityType, getDurationMs(started));
-			}
-		} catch (error) {
-			try {
-				await inboxErrorHandler?.(ctx, error);
-			} catch (error) {
-				logger.error("An unexpected error occurred in inbox error handler:\n{error}", {
-					error,
-					activityId: activity.id?.href,
-					activity: json,
-					recipient
-				});
-			}
-			logger.error("Failed to process the incoming activity {activityId}:\n{error}", {
-				error,
-				activityId: activity.id?.href,
-				activity: json,
-				recipient
-			});
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			recordInboxActivity(meterProvider, "rejected", getTypeId(activity).href);
-			span.end();
-			return "error";
-		}
-		recordInboxActivity(meterProvider, "processed", getTypeId(activity).href);
-		if (cacheKey != null) await kv.set(cacheKey, true, { ttl: Temporal.Duration.from({ days: 1 }) });
-		logger.info("Activity {activityId} has been processed.", {
-			activityId: activity.id?.href,
-			activity: json,
-			recipient
-		});
-		span.end();
-		return "success";
-	});
-}
-//#endregion
-export { routeActivity as n, actorsHaveSameOrigin as t };