@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/{context-Zii1f5xS.d.ts → context-7NyiqIcg.d.ts}

@@ -1,17 +1,115 @@
 /// <reference lib="esnext.temporal" />
-import { o as JsonValue, s as NodeInfo, t as GetNodeInfoOptions } from "./client-CSddvgWN.js";
-import { o as VerifyRequestFailureReason, t as HttpMessageSignaturesSpec } from "./http-lf8Hsd91.js";
-import { n as GetKeyOwnerOptions } from "./owner-CnngXDNJ.js";
-import { n as KvStore, t as KvKey } from "./kv-D6hNiMTK.js";
-import { i as MessageQueue } from "./metrics-Dc4jR-IC.js";
+import { o as JsonValue, s as NodeInfo, t as GetNodeInfoOptions } from "./client-D-XP_Ccb.js";
+import { _ as InboxVerificationKey, d as InboxProofPolicyFailureReason, h as InboxVerificationAttempt, w as VerifyRequestFailureReason, y as HttpMessageSignaturesSpec } from "./key-C1nv7_jD.js";
+import { n as GetKeyOwnerOptions } from "./owner-BSzr5-I8.js";
+import { n as KvStore, t as KvKey } from "./kv-B2mzK5tl.js";
 import { Router } from "@fedify/uri-template";
 import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
 import { MeterProvider, Span, Tracer, TracerProvider } from "@opentelemetry/api";
-import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions } from "@fedify/vocab-runtime";
+import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions, PortableObjectVerifier } from "@fedify/vocab-runtime";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 import { MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/federation/inbox-report.d.ts
+/**
+* A JSON value retained from the incoming request.
+* @since 2.4.0
+*/
+type InboxJsonValue = null | boolean | number | string | readonly InboxJsonValue[] | {
+  readonly [key: string]: InboxJsonValue;
+};
+/**
+* The final inbox authentication decision.
+* @since 2.4.0
+*/
+type InboxAuthentication = {
+  readonly status: "verified"; /** Direct references to the attempts that authenticated this delivery. */
+  readonly attempts: readonly Extract<InboxVerificationAttempt, {
+    status: "verified";
+  }>[];
+} | {
+  readonly status: "rejected";
+  readonly reason: {
+    readonly type: "verificationFailed";
+  } | {
+    readonly type: "actorKeyMismatch";
+    readonly key: InboxVerificationKey;
+    readonly actorIds: readonly URL[];
+  } | {
+    readonly type: "proofPolicy";
+    readonly policy: "portableActor" | "portableActivity" | "compound";
+    readonly detail?: InboxProofPolicyFailureReason;
+  } | {
+    readonly type: "invalidNonce";
+  };
+} | {
+  readonly status: "skipped";
+} | {
+  readonly status: "notDetermined";
+};
+/**
+* How an inbox request finished.
+* @since 2.4.0
+*/
+type InboxRequestOutcome = {
+  readonly type: "response";
+  readonly status: number;
+  readonly disposition: "processed" | "enqueued" | "duplicate" | "unhandled" | "customResponse";
+} | {
+  readonly type: "response";
+  readonly status: number;
+  readonly disposition: "rejected";
+  readonly reason: "recipientNotFound" | "invalidJson" | "invalidJsonLd" | "invalidActivity" | "bodyTooLarge" | "missingActor" | "authentication";
+} | {
+  readonly type: "response";
+  readonly status: number;
+  readonly disposition: "failed";
+  readonly reason: "bodyUnavailable" | "enqueueError" | "listenerError";
+  readonly error?: unknown;
+} | {
+  readonly type: "exception";
+  readonly stage: "prepare" | "parse" | "verify" | "policy" | "dispatch" | "respond"; /** The original thrown value, including null/undefined. */
+  readonly error: unknown;
+};
+/**
+* Observations of a single inbox delivery request.
+* @since 2.4.0
+*/
+interface InboxRequestReport {
+  /** The delivery route, including a portable gateway route. */
+  readonly inbox: {
+    readonly kind: "personal" | "shared" | "portable";
+    readonly recipient: string | null;
+  };
+  /** Unavailable differs from a successfully parsed JSON null. */
+  readonly payload: {
+    readonly status: "unavailable";
+  } | {
+    readonly status: "parsed";
+    readonly value: InboxJsonValue;
+  };
+  /** The Activity obtained by the normal processing flow, if any. */
+  readonly activity: Activity | null;
+  /** Logical evaluations, including unsuccessful fallback paths. */
+  readonly attempts: readonly InboxVerificationAttempt[];
+  /** Cryptographic success alone does not imply this decision is verified. */
+  readonly authentication: InboxAuthentication;
+  /** Response status snapshot or the original exception. */
+  readonly outcome: InboxRequestOutcome;
+}
+/**
+* Observes an inbox delivery after processing, before fetch resolves/rethrows.
+* The callback is awaited.  Its errors are logged and swallowed, preserving
+* the original response/exception.  The last registered callback replaces the
+* previous one.  It excludes inbox collection GETs, unmatched routes,
+* programmatic routing, and queue workers.  This is not an atomic persistence
+* guarantee.  Keys/owner/controller declarations remain untrusted unless the
+* final authentication decision verifies them.
+* @since 2.4.0
+*/
+type InboxRequestFinishedHandler<TContextData> = (context: RequestContext<TContextData>, report: InboxRequestReport) => void | Promise<void>;
+//#endregion
 //#region src/compat/types.d.ts
 /**
 * A function that transforms an activity object.
@@ -145,6 +243,25 @@ type ActorKeyPairsDispatcher<TContextData> = (context: Context<TContextData>, id
 */
 type ActorHandleMapper<TContextData> = (context: Context<TContextData>, username: string) => string | null | Promise<string | null>;
 /**
+* A callback that maps an actor's internal identifier to the ID of the
+* [FEP-ef61] portable actor it dispatches, or `null` if the actor is not
+* portable.
+*
+* The returned ID is an `ap:` or `ap+ef61:` URI, e.g.,
+* `ap+ef61://did:key:z6Mk.../actors/alice`, or its compatible identifier.
+* It must be the same ID that the actor dispatcher puts in the actor's `id`,
+* and must not have a fragment.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @template TContextData The context data to pass to the {@link Context}.
+* @param context The context.
+* @param identifier The actor's internal identifier.
+* @returns The portable actor's ID, or `null` if the actor is not portable.
+* @since 2.4.0
+*/
+type PortableActorIdMapper<TContextData> = (context: Context<TContextData>, identifier: string) => URL | null | Promise<URL | null>;
+/**
 * A callback that maps a WebFinger query to the corresponding actor's
 * internal identifier or username, or `null` if the query is not found.
 * @template TContextData The context data to pass to the {@link Context}.
@@ -164,14 +281,18 @@ type ActorAliasMapper<TContextData> = (context: RequestContext<TContextData>, re
   username: string;
 } | null>;
 /**
-* A callback that dispatches an object.
+* A callback that dispatches an object or a {@link Tombstone}.
+*
+* Return a {@link Tombstone} if the object has been deleted; Fedify then
+* responds with `410 Gone` and the serialized tombstone.  Return `null` if
+* the object is not found.
 *
 * @template TContextData The context data to pass to the {@link Context}.
 * @template TObject The type of object to dispatch.
 * @template TParam The parameter names of the requested URL.
 * @since 0.7.0
 */
-type ObjectDispatcher<TContextData, TObject extends Object$1, TParam extends string> = (context: RequestContext<TContextData>, values: Record<TParam, string>) => TObject | null | Promise<TObject | null>;
+type ObjectDispatcher<TContextData, TObject extends Object$1, TParam extends string> = (context: RequestContext<TContextData>, values: Record<TParam, string>) => TObject | Tombstone | null | Promise<TObject | Tombstone | null>;
 /**
 * A callback that dispatches a collection.
 *
@@ -260,6 +381,60 @@ type OutboxListener<TContextData, TActivity extends Activity> = (context: Outbox
 */
 type MediaUploaderCallback<TContextData> = (context: RequestContext<TContextData>, identifier: string, file: File, object: Object$1) => Object$1 | URL | Promise<Object$1 | URL>;
 /**
+* A request for a resource addressed by a hashlink, which an
+* [FEP-ef61](https://w3id.org/fep/ef61) gateway serves at
+* `/.well-known/apgateway/hl:<digestMultibase>`.
+*
+* Fedify validates the hashlink before creating this object, so the digest is
+* always a well-formed SHA-256 multihash.
+*
+* @since 2.4.0
+*/
+interface HashlinkMediaRequest {
+  /**
+  * The requested hashlink, i.e., `hl:` followed by
+  * {@link HashlinkMediaRequest.digestMultibase}, after percent-decoding and
+  * with its scheme lowercased.
+  */
+  readonly hashlink: `hl:${string}`;
+  /**
+  * The multibase-encoded multihash as requested, which is the value that
+  * publishers put in the `digestMultibase` property.  The same digest can be
+  * encoded in several multibase encodings; use
+  * {@link HashlinkMediaRequest.digest} as a storage key to find a resource
+  * regardless of the encoding.
+  */
+  readonly digestMultibase: string;
+  /** The hash algorithm of the digest. */
+  readonly algorithm: "sha2-256";
+  /** The raw 32-byte SHA-256 digest of the resource. */
+  readonly digest: Uint8Array;
+  /**
+  * The multihash decoded from
+  * {@link HashlinkMediaRequest.digestMultibase}, i.e., the hash algorithm
+  * code and the digest length followed by the digest.
+  */
+  readonly multihash: Uint8Array;
+}
+/**
+* A callback that serves a resource addressed by a hashlink through the
+* [FEP-ef61](https://w3id.org/fep/ef61) gateway endpoint.
+*
+* The returned response is sent as is, so the callback can stream its body
+* and set headers such as `Content-Type` and `Cache-Control`.  Fedify does not
+* verify the response body against the digest, so the complete
+* representation must be the exact bytes that hash to the requested digest.
+*
+* @template TContextData The context data to pass to the {@link Context}.
+* @param context The request context.
+* @param media The requested hashlink and its digest.
+* @returns The response to send, or `null` if the resource is not stored on
+*          this server, which results in `404 Not Found`.  It may be returned
+*          synchronously or wrapped in a `Promise`.
+* @since 2.4.0
+*/
+type HashlinkMediaDispatcher<TContextData> = (context: RequestContext<TContextData>, media: HashlinkMediaRequest) => Response | null | Promise<Response | null>;
+/**
 * The reason why an incoming activity could not be verified.
 *
 * Unlike inbox listeners registered through {@link InboxListenerSetters.on},
@@ -414,6 +589,28 @@ type ObjectAuthorizePredicate<TContextData, TParam extends string> = (context: R
 */
 type CustomCollectionDispatcher<TItem, TParam extends string, TContext extends Context<TContextData>, TContextData> = (context: TContext, values: Record<TParam, string>, cursor: string | null) => PageItems<TItem> | null | Promise<PageItems<TItem> | null>;
 /**
+* A callback that maps a custom collection to the identifier of the actor
+* that owns it, so that the collection can be served as an [FEP-ef61]
+* portable collection through the gateway endpoint, e.g.,
+* `GET /.well-known/apgateway/did:key:z6Mk.../users/alice/bookmarks`.
+*
+* Fedify serves such a request only if the returned actor is a portable actor
+* whose ID is under the requested DID.  The owner has to come from
+* the application's data, not from the request, since the DID in the request
+* path is not evidence that this server hosts collections for it.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @template TContextData The context data to pass to the {@link Context}.
+* @template TParam The parameter names of the requested URL.
+* @param context The context.
+* @param values The parameters of the requested URL.
+* @returns The internal identifier of the actor that owns the collection, or
+*          `null` if the collection is not a portable collection.
+* @since 2.4.0
+*/
+type PortableCollectionOwnerMapper<TContextData, TParam extends string> = (context: Context<TContextData>, values: Record<TParam, string>) => string | null | Promise<string | null>;
+/**
 * A callback that counts the number of items in a custom collection.
 *
 * @template TParams The parameter names of the requested URL.
@@ -509,6 +706,17 @@ type CircuitBreakerOptions = CircuitBreakerFailurePolicy & {
   */
   readonly releaseInterval?: Temporal.Duration | Temporal.DurationLike;
   /**
+  * How long Fedify keeps circuit breaker state in the configured key-value
+  * store.
+  *
+  * When omitted, Fedify derives this from `failureWindow`, `recoveryDelay`, and
+  * `heldActivityTtl` for the default numeric failure policy.  Custom `failure`
+  * callbacks do not have an inspectable time window, so their state expires
+  * after `recoveryDelay` plus `heldActivityTtl` unless this option overrides
+  * it.
+  */
+  readonly stateTtl?: Temporal.Duration | Temporal.DurationLike;
+  /**
   * Called whenever the circuit state changes.
   */
   readonly onStateChange?: (remoteHost: string, previousState: CircuitBreakerState, newState: CircuitBreakerState) => void | Promise<void>;
@@ -527,6 +735,7 @@ interface NormalizedCircuitBreakerOptions {
   readonly recoveryDelay: Temporal.Duration;
   readonly heldActivityTtl: Temporal.Duration;
   readonly releaseInterval: Temporal.Duration;
+  readonly stateTtl: Temporal.Duration | undefined;
   readonly onStateChange?: CircuitBreakerOptions["onStateChange"];
   readonly onActivityDrop?: CircuitBreakerOptions["onActivityDrop"];
 }
@@ -587,6 +796,11 @@ declare class CircuitBreaker {
   recordFailure(remoteHost: string): Promise<CircuitBreakerStateChange | undefined>;
   dropActivity(remoteHost: string, details: CircuitBreakerActivityDrop): Promise<void>;
   getState(remoteHost: string): Promise<CircuitBreakerKvState | undefined>;
+  /**
+  * The currently running background legacy sweep, if any.
+  * @internal
+  */
+  get pendingSweep(): Promise<void> | undefined;
 }
 /**
 * Normalizes user-provided circuit breaker options into the internal policy
@@ -595,7 +809,8 @@ declare class CircuitBreaker {
 * @param options The public circuit breaker options supplied to Fedify.
 * @returns The normalized failure predicate, failure pruning function,
 * duration values, and optional callbacks with defaults applied.
-* @throws {RangeError} If any configured duration is not positive.
+* @throws {RangeError} If any configured duration is not positive, or if
+* `stateTtl` is shorter than `recoveryDelay`.
 * @throws {TypeError} If `failureThreshold` is not a positive integer.
 */
 declare function normalizeCircuitBreakerOptions(options: CircuitBreakerOptions): NormalizedCircuitBreakerOptions;
@@ -608,6 +823,264 @@ declare function normalizeCircuitBreakerOptions(options: CircuitBreakerOptions):
 */
 declare function parseCircuitBreakerKvState(value: unknown): CircuitBreakerKvState | undefined;
 //#endregion
+//#region src/federation/mq.d.ts
+/**
+* Additional options for enqueuing a message in a queue.
+*
+* @since 0.5.0
+*/
+interface MessageQueueEnqueueOptions {
+  /**
+  * The delay before the message is enqueued.  No delay by default.
+  *
+  * It must not be negative.
+  */
+  readonly delay?: Temporal.Duration;
+  /**
+  * An optional key that ensures messages with the same ordering key are
+  * processed sequentially (one at a time).  Messages with different ordering
+  * keys (or no ordering key) may be processed in parallel.
+  *
+  * This is useful for ensuring that related messages are processed in order,
+  * such as ensuring that a `Delete` activity is processed after a `Create`
+  * activity for the same object.
+  *
+  * @since 2.0.0
+  */
+  readonly orderingKey?: string;
+  /**
+  * An optional key requesting at-most-once enqueue semantics for messages
+  * that share it.  A backend that declares
+  * {@link MessageQueue.nativeDeduplication} `true` owns the check: a message
+  * whose `deduplicationKey` was already seen within the backend's
+  * deduplication window is dropped instead of enqueued.  Backends without
+  * native deduplication ignore this field; Fedify performs its own
+  * best-effort deduplication before reaching them on the paths that support
+  * it.
+  *
+  * @since 2.4.0
+  */
+  readonly deduplicationKey?: string;
+}
+/**
+* Additional options for listening to a message queue.
+*
+* @since 1.0.0
+*/
+interface MessageQueueListenOptions {
+  /**
+  * The signal to abort listening to the message queue.
+  */
+  signal?: AbortSignal;
+}
+/**
+* The number of messages waiting in a message queue.
+*
+* @since 2.3.0
+*/
+interface MessageQueueDepth {
+  /**
+  * The total number of messages still waiting in the backend queue.
+  *
+  * This does not include messages that have already been handed to a worker
+  * for processing.
+  */
+  readonly queued: number;
+  /**
+  * The number of queued messages eligible for immediate processing.
+  *
+  * Queue backends that cannot cheaply distinguish ready and delayed messages
+  * may omit this field.
+  */
+  readonly ready?: number;
+  /**
+  * The number of queued messages scheduled for later delivery.
+  *
+  * Queue backends that cannot cheaply distinguish ready and delayed messages
+  * may omit this field.
+  */
+  readonly delayed?: number;
+}
+/**
+* An abstract interface for a message queue.
+*
+* @since 0.5.0
+*/
+interface MessageQueue {
+  /**
+  * Whether the message queue backend provides native retry mechanisms.
+  * When `true`, Fedify will skip its own retry logic and rely on the backend
+  * to handle retries. When `false` or omitted, Fedify will handle retries
+  * using its own retry policies.
+  *
+  * @default `false`
+  * @since 1.7.0
+  */
+  readonly nativeRetrial?: boolean;
+  /**
+  * Whether the message queue backend deduplicates messages that share a
+  * {@link MessageQueueEnqueueOptions.deduplicationKey} natively.  When `true`,
+  * Fedify forwards the `deduplicationKey` and relies on the backend to drop
+  * duplicates; when `false` or omitted, Fedify applies its own best-effort
+  * key–value deduplication on the paths that request it.
+  *
+  * @default `false`
+  * @since 2.4.0
+  */
+  readonly nativeDeduplication?: boolean;
+  /**
+  * Whether {@link enqueueMany} accepts either every message or no messages.
+  * Backends that implement `enqueueMany()` by sending messages individually
+  * must set this to `false`, so Fedify does not use that method for a batch
+  * governed by one `deduplicationKey`.  `true` by default when `enqueueMany`
+  * is implemented.
+  *
+  * @default `true`
+  * @since 2.4.0
+  */
+  readonly atomicEnqueueMany?: boolean;
+  /**
+  * Enqueues a message in the queue.
+  * @param message The message to enqueue.
+  * @param options Additional options for enqueuing the message.
+  */
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  /**
+  * Enqueues multiple messages in the queue.  This operation is optional,
+  * and may not be supported by all implementations.  If not supported,
+  * Fedify will invoke {@link enqueue} for each message.  An implementation
+  * that may accept only part of a batch before rejecting must declare
+  * {@link atomicEnqueueMany} `false`.
+  *
+  * @param messages The messages to enqueue.
+  * @param options Additional options for enqueuing the messages.
+  */
+  enqueueMany?: (messages: readonly any[], options?: MessageQueueEnqueueOptions) => Promise<void>;
+  /**
+  * Listens for messages in the queue.
+  * @param handler The handler for messages in the queue.
+  * @param options Additional options for listening to the message queue.
+  * @returns A promise that resolves when the listening is done.  It never
+  *          rejects, and is resolved when the signal is aborted.  If no
+  *          signal is provided, it never resolves.
+  */
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+  /**
+  * Gets the number of messages waiting in the queue.
+  *
+  * This operation is optional, and may not be supported by all
+  * implementations.  The returned counts exclude messages currently being
+  * handled by a worker.
+  *
+  * @since 2.3.0
+  */
+  getDepth?(): Promise<MessageQueueDepth>;
+}
+/**
+* Additional options for {@link InProcessMessageQueue}.
+* @since 1.0.0
+*/
+interface InProcessMessageQueueOptions {
+  /**
+  * The interval to poll for messages in the queue.  5 seconds by default.
+  * @default `{ seconds: 5 }`
+  */
+  pollInterval?: Temporal.Duration | Temporal.DurationLike;
+}
+/**
+* A message queue that processes messages in the same process.
+* Do not use this in production as it does neither persist messages nor
+* distribute them across multiple processes.
+*
+* @since 0.5.0
+*/
+declare class InProcessMessageQueue implements MessageQueue {
+  #private;
+  /**
+  * In-process message queue does not provide native retry mechanisms.
+  * @since 1.7.0
+  */
+  readonly nativeRetrial = false;
+  /**
+  * In-process message queue does not deduplicate messages natively.
+  * @since 2.4.0
+  */
+  readonly nativeDeduplication = false;
+  /**
+  * Constructs a new {@link InProcessMessageQueue} with the given options.
+  * @param options Additional options for the in-process message queue.
+  */
+  constructor(options?: InProcessMessageQueueOptions);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+  getDepth(): Promise<MessageQueueDepth>;
+}
+/**
+* A message queue that processes messages in parallel.  It takes another
+* {@link MessageQueue}, and processes messages in parallel up to a certain
+* number of workers.
+*
+* Actually, it's rather a decorator than a queue itself.
+*
+* Note that the workers do not run in truly parallel, in the sense that they
+* are not running in separate threads or processes.  They are running in the
+* same process, but are scheduled to run in parallel.  Hence, this is useful
+* for I/O-bound tasks, but not for CPU-bound tasks, which is okay for Fedify's
+* workloads.
+*
+* When using `ParallelMessageQueue`, the ordering guarantee is preserved
+* *only if* the underlying queue implementation delivers messages in a wrapper
+* format that includes the `__fedify_ordering_key__` property.  Currently,
+* only `DenoKvMessageQueue` and `WorkersMessageQueue` use this format.
+* For other queue implementations (e.g., `InProcessMessageQueue`,
+* `RedisMessageQueue`, `PostgresMessageQueue`, `SqliteMessageQueue`,
+* `AmqpMessageQueue`), the ordering key cannot be detected by
+* `ParallelMessageQueue`, so ordering guarantees are handled by those
+* implementations directly rather than at the `ParallelMessageQueue` level.
+*
+* Messages with the same ordering key will never be processed concurrently
+* by different workers, ensuring sequential processing within each key.
+* Messages with different ordering keys (or no ordering key) can still be
+* processed in parallel.
+*
+* @since 1.0.0
+*/
+declare class ParallelMessageQueue implements MessageQueue {
+  #private;
+  readonly queue: MessageQueue;
+  readonly workers: number;
+  /**
+  * Inherits the native retry capability from the wrapped queue.
+  * @since 1.7.0
+  */
+  readonly nativeRetrial?: boolean;
+  /**
+  * Inherits the native deduplication capability from the wrapped queue.
+  * @since 2.4.0
+  */
+  readonly nativeDeduplication?: boolean;
+  /**
+  * Inherits the atomic batch capability from the wrapped queue.
+  * @since 2.4.0
+  */
+  readonly atomicEnqueueMany?: boolean;
+  readonly getDepth?: () => Promise<MessageQueueDepth>;
+  /**
+  * Constructs a new {@link ParallelMessageQueue} with the given queue and
+  * number of workers.
+  * @param queue The message queue to use under the hood.  Note that
+  *              {@link ParallelMessageQueue} cannot be nested.
+  * @param workers The number of workers to process messages in parallel.
+  * @throws {TypeError} If the given queue is an instance of
+  *                     {@link ParallelMessageQueue}.
+  */
+  constructor(queue: MessageQueue, workers: number);
+  enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
+}
+//#endregion
 //#region src/federation/handler.d.ts
 /**
 * Options for the {@link respondWithObject} and
@@ -885,6 +1358,18 @@ interface FanoutMessage {
   readonly inboxes: Readonly<Record<string, {
     readonly actorIds: readonly string[];
     readonly sharedInbox: boolean;
+    /**
+    * The canonical form of the FEP-ef61 portable inbox that the inbox
+    * stands for.
+    * @internal
+    */
+    readonly portableInbox?: string;
+    /**
+    * The compatible identifiers of the portable inbox on each gateway to
+    * deliver through, in order.
+    * @internal
+    */
+    readonly gatewayInboxes?: readonly string[];
   }>>;
   readonly activity: unknown;
   readonly activityId?: string;
@@ -928,6 +1413,27 @@ interface OutboxMessage {
   * @internal
   */
   readonly circuitHeldSince?: string;
+  /**
+  * The canonical form of the FEP-ef61 portable inbox that {@link inbox}, its
+  * compatible identifier on a gateway, stands for.
+  * @internal
+  */
+  readonly portableInbox?: string;
+  /**
+  * The compatible identifiers of the FEP-ef61 portable inbox on each gateway
+  * that is still to be tried, in order.  {@link inbox} is the first one.
+  * If there is more than one, the activity is delivered through the first
+  * gateway that accepts it.
+  * @internal
+  */
+  readonly gatewayInboxes?: readonly string[];
+  /**
+  * The times before which each of {@link gatewayInboxes} must not be tried
+  * again, as their responses' `Retry-After` headers requested, keyed by
+  * the inbox URL, in ISO 8601.
+  * @internal
+  */
+  readonly gatewayNotBefore?: Readonly<Record<string, string>>;
   readonly traceContext: Readonly<Record<string, string>>;
 }
 /**
@@ -1076,6 +1582,16 @@ interface FederationKvPrefixes {
   * @since 2.4.0
   */
   readonly taskDeduplication: KvKey;
+  /**
+  * The key prefix used for remembering which activities received in
+  * [FEP-ef61] portable inboxes have been forwarded to which gateways, so that
+  * each activity is forwarded at most once.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @default `["_fedify", "portableInboxForwarding"]`
+  * @since 2.4.0
+  */
+  readonly portableInboxForwarding: KvKey;
 }
 /**
 * Options for {@link FederationOptions.origin} when it is not a string.
@@ -1101,6 +1617,8 @@ interface FederationOrigin {
 * @returns A new {@link Federation} instance.
 * @throws {TypeError} If benchmark mode and `meterProvider` are both
 * specified.
+* @throws {RangeError} If {@link FederationOptions.maxHttpSignatures} is not
+* a positive integer or `Infinity`.
 * @since 0.10.0
 */
 declare function createFederation<TContextData>(options: FederationOptions<TContextData>): Federation<TContextData>;
@@ -1182,7 +1700,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1196,7 +1716,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1210,7 +1732,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}{${TParam}}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1224,7 +1748,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}${Rfc6570Expression<TParam>}${string}${Rfc6570Expression<TParam>}${string}${Rfc6570Expression<TParam>}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1238,7 +1764,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}${Rfc6570Expression<TParam>}${string}${Rfc6570Expression<TParam>}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1252,7 +1780,9 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   *             based on URI Template
   *             ([RFC 6570](https://tools.ietf.org/html/rfc6570)).  The path
   *             must have one or more variables.
-  * @param dispatcher An object dispatcher callback to register.
+  * @param dispatcher An object dispatcher callback to register.  It may
+  *                   return an object, a `Tombstone` if the object has been
+  *                   deleted, or `null` if the object is not found.
   */
   setObjectDispatcher<TObject extends Object$1, TParam extends string>(cls: ConstructorWithTypeId<TObject>, path: `${string}${Rfc6570Expression<TParam>}${string}`, dispatcher: ObjectDispatcher<TContextData, TObject, TParam>): ObjectCallbackSetters<TContextData, TObject, TParam>;
   /**
@@ -1360,6 +1890,53 @@ interface Federatable<TContextData> extends TaskRegistry<TContextData> {
   */
   setMediaUploader(path: `${string}${Rfc6570Expression<"identifier">}${string}`, callback: MediaUploaderCallback<TContextData>): MediaUploaderSetters<TContextData>;
   /**
+  * Registers a dispatcher that serves resources addressed by hashlinks, such
+  * as media attached to portable objects, through the
+  * [FEP-ef61](https://w3id.org/fep/ef61) gateway endpoint, e.g.,
+  * `GET /.well-known/apgateway/hl:zQmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n`.
+  *
+  * Fedify responds with `400 Bad Request` without calling the dispatcher if
+  * the hashlink is malformed or its digest is not a SHA-256 multihash, and
+  * with `404 Not Found` if the dispatcher returns `null`.  Otherwise, the
+  * response returned by the dispatcher is sent as is.  Requests with methods
+  * other than `GET` and `HEAD` get `405 Method Not Allowed`.
+  *
+  * Fedify does not verify the served bytes against the digest, as that would
+  * require buffering the whole response body.  The dispatcher must serve only
+  * the resource whose complete representation hashes to the requested
+  * digest, e.g., by using the digest as the storage key.
+  *
+  * This is not the upload API of the ActivityPub Media Upload extension,
+  * which is registered through {@link Federatable.setMediaUploader}.
+  *
+  * @example
+  * ``` typescript
+  * federation.setHashlinkMediaDispatcher(async (ctx, media) => {
+  *   const file = await findPublicMedia(media.digest);
+  *   if (file == null) return null;
+  *   return new Response(
+  *     ctx.request.method === "HEAD" ? null : file.stream(),
+  *     {
+  *       headers: {
+  *         "Content-Type": file.mediaType,
+  *         "Content-Length": file.size.toString(),
+  *         "Cache-Control": "public, max-age=31536000, immutable",
+  *         "X-Content-Type-Options": "nosniff",
+  *       },
+  *     },
+  *   );
+  * });
+  * ```
+  *
+  * @param dispatcher A callback that returns the response serving the
+  *                   requested resource, or `null` if it is not stored on
+  *                   this server.
+  * @throws {RouterError} Thrown if a hashlink media dispatcher is already
+  *                       registered.
+  * @since 2.4.0
+  */
+  setHashlinkMediaDispatcher(dispatcher: HashlinkMediaDispatcher<TContextData>): void;
+  /**
   * Registers a following collection dispatcher.
   * @param path The URI path pattern for the following collection.  The syntax
   *             is based on URI Template
@@ -1635,6 +2212,47 @@ interface FederationBuilder<TContextData> extends Federatable<TContextData> {
   build(options: FederationOptions<TContextData>): Promise<Federation<TContextData>>;
 }
 /**
+* Options for forwarding activities received in [FEP-ef61] portable inboxes to
+* the other gateways of their actors.  See
+* {@link FederationOptions.portableInboxForwarding}.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @since 2.4.0
+*/
+interface PortableInboxForwardingOptions {
+  /**
+  * The maximum number of other gateways that a single delivery is forwarded
+  * to.  Gateways beyond it are skipped with a warning.  `0` turns off
+  * forwarding.
+  * @default `10`
+  */
+  maxTargets?: number;
+  /**
+  * How long Fedify remembers that it has forwarded an activity from
+  * a portable inbox to a gateway, under
+  * {@link FederationKvPrefixes.portableInboxForwarding}.  Within it, the same
+  * activity is never forwarded to the same gateway again; once it expires,
+  * a redelivery of the activity may be forwarded again.  It cannot have
+  * calendar units, i.e., weeks, months, or years.
+  * @default `{ days: 30 }`
+  */
+  ttl?: Temporal.DurationLike;
+  /**
+  * How long a delivery waits for forwarding requests made immediately, i.e.,
+  * when no outbox queue is configured, before Fedify responds to it.
+  * Requests still running afterwards continue in the background.  It also
+  * bounds verifying the HTTP Signature that identifies the gateway which
+  * forwarded the delivery, with or without an outbox queue; if the
+  * verification does not finish in time, the activity is forwarded to that
+  * gateway as well.  It cannot have calendar units,
+  * i.e., weeks, months, or years, and cannot be longer than
+  * 2,147,483,647 milliseconds (about 24.8 days), the longest delay timers
+  * support.
+  * @default `{ seconds: 10 }`
+  */
+  deadline?: Temporal.DurationLike;
+}
+/**
 * Policy for emitting `Accept-Signature` challenges on inbox `401`
 * responses, as defined in
 * [RFC 9421 §5](https://www.rfc-editor.org/rfc/rfc9421#section-5).
@@ -1702,6 +2320,41 @@ interface FederationOptions<TContextData> {
   */
   kvPrefixes?: Partial<FederationKvPrefixes>;
   /**
+  * The time-to-live for a remote actor's public key cached under
+  * {@link FederationKvPrefixes.publicKey}.  Once it expires, the next
+  * signature verification that needs the key refetches it from the remote
+  * server and caches it again.
+  *
+  * Shortening it bounds how long a revoked or rotated key stays in the cache,
+  * at the cost of more requests to remote servers; refetching an expired key
+  * fails while the peer is unavailable, so a very short value makes
+  * verification depend on the peer being reachable.
+  * @default `{ days: 30 }`
+  * @since 2.4.0
+  */
+  publicKeyTtl?: Temporal.DurationLike;
+  /**
+  * The time-to-live for a remote origin's remembered HTTP Message Signatures
+  * spec cached under {@link FederationKvPrefixes.httpMessageSignaturesSpec}.
+  * Once it expires, the next delivery to that origin relearns the spec by
+  * double-knocking and remembers it again.
+  *
+  * Shortening it makes Fedify notice a peer's spec upgrade sooner, at the
+  * cost of an extra signed request per delivery whenever the first spec tried
+  * is rejected.
+  * @default `{ days: 90 }`
+  * @since 2.4.0
+  */
+  httpMessageSignaturesSpecTtl?: Temporal.DurationLike;
+  /**
+  * Options for forwarding activities received in [FEP-ef61] portable inboxes
+  * to the other gateways of their actors.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @since 2.4.0
+  */
+  portableInboxForwarding?: PortableInboxForwardingOptions;
+  /**
   * The message queue for sending and receiving activities.  If not provided,
   * activities will not be queued and will be processed immediately.
   *
@@ -1752,7 +2405,8 @@ interface FederationOptions<TContextData> {
   */
   authenticatedDocumentLoaderFactory?: AuthenticatedDocumentLoaderFactory;
   /**
-  * Whether to allow fetching private network addresses in the document loader.
+  * Whether to allow private network addresses in the document loader and
+  * outbound activity delivery, including redirects.
   *
   * If turned on, {@link FederationOptions.documentLoader},
   * {@link FederationOptions.contextLoader}, and
@@ -1789,6 +2443,35 @@ interface FederationOptions<TContextData> {
   */
   userAgent?: GetUserAgentOptions | string;
   /**
+  * The timeout for each call of the built-in document loader, context
+  * loader, and authenticated document loader, e.g., when Fedify fetches
+  * a key to verify a signature.  The timeout is shared by all the steps of
+  * a call, including every redirect it follows, retries, and reading the
+  * response body.  It does not cover the time spent reading from or
+  * writing to the cache.
+  *
+  * A timed-out call throws a `FetchError` without a response, whose
+  * `cause` is a `DOMException` named `"TimeoutError"`, so that, e.g.,
+  * a key fetch that times out is reported as a `keyFetchError` and cached
+  * like other failures to fetch a key.
+  *
+  * It does not affect loaders made by
+  * {@link FederationOptions.documentLoaderFactory},
+  * {@link FederationOptions.contextLoaderFactory}, or
+  * {@link FederationOptions.authenticatedDocumentLoaderFactory}.
+  * Note that if only {@link FederationOptions.documentLoaderFactory} is
+  * set, it also makes context loaders.
+  *
+  * Set it to `null` to turn off the timeout.
+  *
+  * 10 seconds by default.
+  * @throws {RangeError} If the duration is not positive, is longer than
+  *                      about 24.8 days, or is given in calendar units
+  *                      such as months.
+  * @since 2.4.0
+  */
+  documentLoaderTimeout?: Temporal.Duration | Temporal.DurationLike | null;
+  /**
   * A callback that handles errors during outbox processing.  Note that this
   * callback can be called multiple times for the same activity, because
   * the delivery is retried according to the backoff schedule until it
@@ -1817,6 +2500,29 @@ interface FederationOptions<TContextData> {
   */
   signatureTimeWindow?: Temporal.Duration | Temporal.DurationLike | false;
   /**
+  * The maximum number of [RFC 9421] signatures of an incoming request to
+  * verify, e.g., in the inbox and in
+  * {@link RequestContext.getSignedKey}.  A request can carry several
+  * signatures, each of which may make Fedify fetch the key that it names,
+  * so only the first ones in the order of the `Signature-Input` header are
+  * verified, and the rest are ignored as if they were absent.  Every
+  * signature among the first ones counts, even if it fails before its key
+  * is fetched.  See also the `maxSignatures` option of `verifyRequest()`.
+  *
+  * It has to be a positive integer, or `Infinity` to verify every
+  * signature, which lets a single request make Fedify fetch any number of
+  * keys.  Draft-cavage HTTP Signatures carry a single signature, so this
+  * option does not affect them.
+  *
+  * Three by default.
+  *
+  * [RFC 9421]: https://www.rfc-editor.org/rfc/rfc9421
+  * @throws {RangeError} Thrown when the federation is created if the value
+  *         is not a positive integer or `Infinity`.
+  * @since 2.4.0
+  */
+  maxHttpSignatures?: number;
+  /**
   * Whether to skip HTTP Signatures verification for incoming activities.
   * This is useful for testing purposes, but should not be used in production.
   *
@@ -1995,6 +2701,30 @@ interface ActorCallbackSetters<TContextData> {
   */
   mapAlias(mapper: ActorAliasMapper<TContextData>): ActorCallbackSetters<TContextData>;
   /**
+  * Sets the callback function that maps an actor's identifier to the ID of
+  * the [FEP-ef61] portable actor it dispatches.  If the callback returns
+  * a portable ID for an identifier, the key pairs of that actor are treated
+  * as this server's *gateway keys* for the portable actor:
+  * {@link Context.getActorKeyPairs} derives their key IDs from the actor's
+  * compatible identifier on this server, e.g.,
+  * `https://example.com/.well-known/apgateway/did:key:z6Mk.../actors/alice#main-key`,
+  * and makes the portable actor their owner, so that requests this server
+  * makes on behalf of the actor, such as activity deliveries and signed
+  * fetches, are signed with them.  Gateway keys are only used for HTTP
+  * Signatures; they never make Object Integrity Proofs or Linked Data
+  * Signatures.
+  *
+  * If it's omitted, or it returns `null`, the actor's keys are derived from
+  * {@link Context.getActorUri} as usual.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @param mapper A callback that maps an actor's identifier to its portable
+  *               ID, or `null` if the actor is not portable.
+  * @returns The setters object so that settings can be chained.
+  * @since 2.4.0
+  */
+  mapPortableActorId(mapper: PortableActorIdMapper<TContextData>): ActorCallbackSetters<TContextData>;
+  /**
   * Maps a fixed path to a sentinel identifier.  It is useful for exposing
   * a single, instance-level actor at a fixed path, such as `/actor` for
   * a relay or `/bot` for a bot.
@@ -2159,6 +2889,16 @@ interface InboxListenerSetters<TContextData> {
   */
   onError(handler: InboxErrorHandler<TContextData>): InboxListenerSetters<TContextData>;
   /**
+  * Observes each configured inbox delivery once, before fetch finishes.
+  * The callback is awaited and its errors do not alter delivery processing.
+  * Calling this again replaces the previous callback.  Built federations
+  * retain the callback registered at build time.
+  * @param handler The request completion observer.
+  * @returns This setter for chaining.
+  * @since 2.4.0
+  */
+  onRequestFinished(handler: InboxRequestFinishedHandler<TContextData>): InboxListenerSetters<TContextData>;
+  /**
   * Registers a callback for incoming activities whose HTTP signatures could
   * not be verified.
   *
@@ -2297,6 +3037,21 @@ interface CustomCollectionCallbackSetters<TParam extends string, TContext extend
   * @since 0.7.0
   */
   authorize(predicate: ObjectAuthorizePredicate<TContextData, string>): CustomCollectionCallbackSetters<TParam, TContext, TContextData>;
+  /**
+  * Maps the custom collection to the actor that owns it, so that it is also
+  * served as an [FEP-ef61] portable collection through the gateway endpoint,
+  * e.g., `GET /.well-known/apgateway/did:key:z6Mk.../users/alice/bookmarks`,
+  * if the owner is a portable actor under the requested DID.  Without it,
+  * the custom collection is not served through the gateway endpoint.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @param mapper A callback that returns the identifier of the actor that
+  *               owns the collection, or `null` if the collection is not
+  *               portable.
+  * @returns The setters object so that settings can be chained.
+  * @since 2.4.0
+  */
+  mapPortableOwner(mapper: PortableCollectionOwnerMapper<TContextData, TParam>): CustomCollectionCallbackSetters<TParam, TContext, TContextData>;
 }
 /**
 * Represents an object with a type ID, which is either a constructor or an
@@ -2393,6 +3148,28 @@ interface Context<TContextData> {
   */
   readonly contextLoader: DocumentLoader;
   /**
+  * The [FEP-ef61] portable object policy that this context applies to
+  * portable objects it dereferences.  It is `verifyPortableObject()` with
+  * this context's document loader, context loader, and tracer provider as
+  * defaults, which the options passed to it override.
+  *
+  * Since its name is the same as the `verifyPortableObject` option of
+  * property accessors, `lookupObject()`, and `traverseCollection()`, passing
+  * a context as their options applies the policy, e.g.,
+  * `await create.getObject(ctx)`.  Objects parsed with a context as options,
+  * such as activities that inboxes receive, and objects that accessors
+  * fetch with a context as options also use it by default for their
+  * property accessors.  It never verifies an object by itself being
+  * there: it only applies to objects that are dereferenced.
+  *
+  * It is optional only so that custom implementations of this interface
+  * keep working; contexts that Fedify creates always have it.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @since 2.4.0
+  */
+  readonly verifyPortableObject?: PortableObjectVerifier;
+  /**
   * The federation object that this context belongs to.
   * @since 1.6.0
   */
@@ -2421,16 +3198,108 @@ interface Context<TContextData> {
   */
   getActorUri(identifier: string): URL;
   /**
-  * Builds the URI of an object with the given class and values.
-  * @param cls The class of the object.
-  * @param values The values to pass to the object dispatcher.
-  * @returns The object's URI.
+  * Builds the [FEP-ef61] portable ID of an actor with the given identifier
+  * under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getActorUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice`.  Such an actor can be served
+  * through the FEP-ef61 gateway endpoint,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice`, by the same actor
+  * dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice`.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.  A `did:key` DID must be
+  *                  encoded in base58-btc, as FEP-ef61 requires; see
+  *                  `exportDidKey()` from `@fedify/vocab-runtime`.
+  * @returns The actor's portable ID.
+  * @throws {RouterError} If no actor dispatcher is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableActorUri(identifier: string, authority: string): URL;
+  /**
+  * Builds the URI of an object with the given class and values.
+  * @param cls The class of the object.
+  * @param values The values to pass to the object dispatcher.
+  * @returns The object's URI.
   * @throws {RouterError} If no object dispatcher is available for the class.
   * @throws {TypeError} If values are invalid.
   * @since 0.7.0
   */
   getObjectUri<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an object with the given class and
+  * values under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getObjectUri} builds from
+  * the object dispatcher's path, but the result is an `ap+ef61:` URI whose
+  * authority is the DID, e.g., `ap+ef61://did:key:z6Mk.../notes/123`.
+  * Such an object can be served through the FEP-ef61 gateway endpoint,
+  * `/.well-known/apgateway/did:key:z6Mk.../notes/123`, by the same object
+  * dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string, e.g.,
+  * `ap+ef61://did:key:z6Mk.../notes/123`.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param cls The class of the object.
+  * @param values The values to pass to the object dispatcher.
+  * @param authority The DID that controls the object, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The object's portable ID.
+  * @throws {RouterError} If no object dispatcher is available for the class.
+  * @throws {TypeError} If values are invalid, or the authority is not a DID
+  *                     or is a `did:key` DID that is not encoded in
+  *                     base58-btc.
+  * @since 2.4.0
+  */
+  getPortableObjectUri<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>, authority: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's inbox with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getInboxUri} builds from
+  * the inbox path, but the result is an `ap+ef61:` URI whose authority is
+  * the DID, e.g., `ap+ef61://did:key:z6Mk.../users/alice/inbox`.  If
+  * a portable actor has it as its `inbox` and lists this server in its
+  * `gateways`, this server accepts deliveries to the inbox through
+  * the FEP-ef61 gateway endpoint, e.g.,
+  * `POST /.well-known/apgateway/did:key:z6Mk.../users/alice/inbox`, and
+  * dispatches them to the inbox listeners.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The inbox's portable ID.
+  * @throws {RouterError} If no inbox path is registered.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableInboxUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's outbox with the given identifier.
   * @param identifier The actor's identifier.
   * @returns The actor's outbox URI.
@@ -2438,6 +3307,35 @@ interface Context<TContextData> {
   */
   getOutboxUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's outbox with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getOutboxUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/outbox`.  If a portable actor has
+  * it as its `outbox` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/outbox`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The outbox's portable ID.
+  * @throws {RouterError} If no outbox dispatcher is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableOutboxUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's media upload endpoint with the given
   * identifier.  This is the endpoint advertised under `endpoints.uploadMedia`
   * in the actor document.
@@ -2469,6 +3367,35 @@ interface Context<TContextData> {
   */
   getFollowingUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's following collection with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getFollowingUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/following`.  If a portable actor has
+  * it as its `following` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/following`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The following collection's portable ID.
+  * @throws {RouterError} If no following collection is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableFollowingUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's followers collection with the given
   * identifier.
   * @param identifier The actor's identifier.
@@ -2477,6 +3404,35 @@ interface Context<TContextData> {
   */
   getFollowersUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's followers collection with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getFollowersUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/followers`.  If a portable actor has
+  * it as its `followers` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/followers`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The followers collection's portable ID.
+  * @throws {RouterError} If no followers collection is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableFollowersUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's liked collection with the given identifier.
   * @param identifier The actor's identifier.
   * @returns The actor's liked collection URI.
@@ -2485,6 +3441,35 @@ interface Context<TContextData> {
   */
   getLikedUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's liked collection with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getLikedUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/liked`.  If a portable actor has
+  * it as its `liked` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/liked`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The liked collection's portable ID.
+  * @throws {RouterError} If no liked collection is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableLikedUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's featured collection with the given identifier.
   * @param identifier The actor's identifier.
   * @returns The actor's featured collection URI.
@@ -2493,6 +3478,35 @@ interface Context<TContextData> {
   */
   getFeaturedUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's featured collection with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getFeaturedUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/featured`.  If a portable actor has
+  * it as its `featured` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/featured`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The featured collection's portable ID.
+  * @throws {RouterError} If no featured collection is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableFeaturedUri(identifier: string, authority: string): URL;
+  /**
   * Builds the URI of an actor's featured tags collection with the given
   * identifier.
   * @param identifier The actor's identifier.
@@ -2502,13 +3516,68 @@ interface Context<TContextData> {
   */
   getFeaturedTagsUri(identifier: string): URL;
   /**
+  * Builds the [FEP-ef61] portable ID of an actor's featured tags collection with the given
+  * identifier under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getFeaturedTagsUri} builds, but
+  * the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/tags`.  If a portable actor has
+  * it as its `featuredTags` and its ID is under the same DID, the collection is
+  * served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/tags`, by the same
+  * collection dispatcher.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The featured tags collection's portable ID.
+  * @throws {RouterError} If no featured tags collection is available.
+  * @throws {TypeError} If the authority is not a DID, or it is a `did:key`
+  *                     DID that is not encoded in base58-btc.
+  * @since 2.4.0
+  */
+  getPortableFeaturedTagsUri(identifier: string, authority: string): URL;
+  /**
   * Determines the type of the URI and extracts the associated data.
+  *
+  * By default, only URIs on this server's origin are recognized.  With
+  * the `portable` option, [FEP-ef61] portable IDs, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice`, and their compatible
+  * identifiers on any gateway, e.g.,
+  * `https://example.com/.well-known/apgateway/did:key:z6Mk.../users/alice`,
+  * are also recognized by the same paths that the gateway endpoint routes
+  * to the dispatchers, and the result has the DID in its `authority`
+  * property.
+  *
+  * The DID of a portable ID is anyone's to choose, so recognizing it does
+  * not mean that this server hosts anything for the DID.  Check that
+  * `authority` is the DID that the application stores for the actor or
+  * object before acting on it:
+  *
+  * ~~~~ typescript
+  * const parsed = ctx.parseUri(follow.objectId, { portable: true });
+  * if (parsed?.type !== "actor") return;
+  * const user = await getUser(parsed.identifier);
+  * if (user == null) return;
+  * if (parsed.authority != null && parsed.authority !== user.did) return;
+  * ~~~~
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
   * @param uri The URI to parse.
+  * @param options Options for parsing the URI.  Since 2.4.0.
   * @returns The result of parsing the URI.  If `null` is given or
   *          the URI is not recognized, `null` is returned.
   * @since 0.9.0
   */
-  parseUri(uri: URL | null): ParseUriResult | null;
+  parseUri(uri: URL | null, options?: ParseUriOptions): ParseUriResult | null;
   /**
   * Gets the key pairs for an actor.
   * @param identifier The actor's identifier.
@@ -2576,7 +3645,16 @@ interface Context<TContextData> {
   * ```
   *
   * It's almost the same as the {@link lookupObject} function, but it uses
-  * the context's document loader and context loader by default.
+  * the context's document loader and context loader by default.  It also
+  * uses {@link Context.verifyPortableObject} as the `verifyPortableObject`
+  * option by default (since 2.4.0), so [FEP-ef61] portable objects,
+  * including portable actors found through WebFinger, are looked up through
+  * their gateways and returned only if they have valid proofs, or, for
+  * collections without proofs, if they are served by gateways that their
+  * owners list.  The returned object uses the same policy by default for
+  * its property accessors.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
   *
   * @param identifier The URI or fediverse handle to look up.
   * @param options Lookup options.
@@ -2600,7 +3678,9 @@ interface Context<TContextData> {
   * ```
   *
   * It's almost the same as the {@link traverseCollection} function, but it
-  * uses the context's document loader and context loader by default.
+  * uses the context's document loader and context loader by default.  It
+  * also uses {@link Context.verifyPortableObject} as the
+  * `verifyPortableObject` option by default (since 2.4.0).
   * @param collection The collection to traverse.
   * @param options Options for traversing the collection.
   * @returns An async iterable of each item in the collection.
@@ -2749,6 +3829,61 @@ interface Context<TContextData> {
   * @since 1.8.0
   */
   getCollectionUri<TParam extends Record<string, string>>(name: string | symbol, values: TParam): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of a custom collection with the given
+  * name and values under the given DID authority.
+  *
+  * The path is the same as the one {@link Context.getCollectionUri} builds,
+  * but the result is an `ap+ef61:` URI whose authority is the DID, e.g.,
+  * `ap+ef61://did:key:z6Mk.../users/alice/bookmarks`.  If the collection
+  * dispatcher maps the collection to a portable actor under the same DID
+  * with `CustomCollectionCallbackSetters.mapPortableOwner()`, the
+  * collection is served through the FEP-ef61 gateway endpoint, e.g.,
+  * `/.well-known/apgateway/did:key:z6Mk.../users/alice/bookmarks`.
+  *
+  * The returned `URL` keeps the DID authority percent-encoded, because
+  * the `URL` class cannot represent the canonical form.  Use `formatIri()`
+  * from `@fedify/vocab-runtime` to get the canonical string.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param name The name of the collection, which can be a string or a symbol.
+  * @param values The values of the URI parameters.
+  * @param authority The DID that controls the collection, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.
+  * @returns The collection's portable ID.
+  * @throws {RouterError} If no collection dispatcher is available for
+  *                       the name.
+  * @throws {TypeError} If values are invalid, or the authority is not a DID
+  *                     or is a `did:key` DID that is not encoded in
+  *                     base58-btc.
+  * @since 2.4.0
+  */
+  getPortableCollectionUri<TParam extends Record<string, string>>(name: string | symbol, values: TParam, authority: string): URL;
+}
+/**
+* Information about an [FEP-ef61] portable object requested through
+* the gateway endpoint.  See {@link RequestContext.portableRequest}.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @since 2.4.0
+*/
+interface PortableRequest {
+  /**
+  * The DID authority of the requested portable object, e.g.,
+  * `did:key:z6Mk...`.  It comes from the request path, so it is not
+  * evidence that this server hosts objects for the DID.
+  */
+  readonly authority: string;
+  /**
+  * The ID of the requested portable object or collection, e.g.,
+  * `ap+ef61://did:key:z6Mk.../notes/123`, without a query.  Like other
+  * portable IDs, the `URL` keeps the DID authority percent-encoded; use
+  * `formatIri()` from `@fedify/vocab-runtime` to get the canonical string.
+  * Each access returns a new `URL` instance.
+  */
+  readonly id: URL;
 }
 /**
 * Options for {@link RequestContext.getActor}.
@@ -2764,6 +3899,23 @@ interface GetActorOptions {
   readonly tombstone?: "suppress" | "passthrough";
 }
 /**
+* Options for {@link RequestContext.getObject}.
+* @since 2.4.0
+*/
+interface GetObjectOptions {
+  /**
+  * Controls how tombstoned objects are returned.
+  *
+  * By default, or if set to `"suppress"`, a {@link Tombstone} is returned as
+  * `null`, unless it is an instance of the requested class, e.g., when
+  * the requested class is `Object` or `Tombstone` itself.  In that case,
+  * the tombstone is returned as is, as it is an object of the requested
+  * class.  Set this to `"passthrough"` to always receive a {@link Tombstone}
+  * result instead of `null`.
+  */
+  readonly tombstone?: "suppress" | "passthrough";
+}
+/**
 * A context for a request.
 */
 interface RequestContext<TContextData> extends Context<TContextData> {
@@ -2776,6 +3928,243 @@ interface RequestContext<TContextData> extends Context<TContextData> {
   */
   readonly url: URL;
   /**
+  * Information about the [FEP-ef61] portable object requested through
+  * the gateway endpoint, e.g.,
+  * `GET /.well-known/apgateway/did:key:z6Mk.../notes/123`, which is served
+  * by an object dispatcher, the actor dispatcher, or a collection
+  * dispatcher.  It is `undefined` for ordinary requests.
+  *
+  * The authority comes from the request path, so it is not evidence that
+  * this server hosts objects for the DID.  An object dispatcher or the actor
+  * dispatcher has to check that by itself.  A portable collection is served
+  * only if its owner, which the actor dispatcher looks up without this
+  * property, is a portable actor under the DID.
+  *
+  * It describes the incoming request, so it stays the same in contexts
+  * derived from this one, e.g., by {@link RequestContext.getObject}.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @since 2.4.0
+  */
+  readonly portableRequest?: PortableRequest;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor with the given identifier.
+  * It works the same as {@link Context.getPortableActorUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * The DID in the request comes from the request path, so the default is
+  * only a convenience for building IDs; it is not evidence that this server
+  * hosts the actor for the DID.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.  Defaults to the DID of
+  *                  the requested portable object.
+  * @returns The actor's portable ID.
+  * @throws {RouterError} If no actor dispatcher is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableActorUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an object with the given class and
+  * values.  It works the same as {@link Context.getPortableObjectUri}, except
+  * that the authority can be omitted while handling a portable gateway
+  * request.  In that case, the DID in {@link RequestContext.portableRequest}
+  * is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param cls The class of the object.
+  * @param values The values to pass to the object dispatcher.
+  * @param authority The DID that controls the object, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.  Defaults to the DID of
+  *                  the requested portable object.
+  * @returns The object's portable ID.
+  * @throws {RouterError} If no object dispatcher is available for the class.
+  * @throws {TypeError} If values are invalid, the authority is not a DID,
+  *                     it is a `did:key` DID that is not encoded in
+  *                     base58-btc, or the authority is omitted outside
+  *                     a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableObjectUri<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's inbox with the given
+  * identifier.  It works the same as {@link Context.getPortableInboxUri},
+  * except that the authority can be omitted while handling a portable object
+  * request, i.e., when {@link RequestContext.portableRequest} is set.  In
+  * that case, its DID is used.  Deliveries to portable inboxes do not set
+  * {@link RequestContext.portableRequest}, so pass the authority explicitly
+  * while handling them.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  It must be a bare DID, without
+  *                  a path, query, or fragment.  Defaults to the DID of
+  *                  the requested portable object, if any.
+  * @returns The inbox's portable ID.
+  * @throws {RouterError} If no inbox path is registered.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableInboxUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's outbox with the given
+  * identifier.  It works the same as {@link Context.getPortableOutboxUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The outbox's portable ID.
+  * @throws {RouterError} If no outbox dispatcher is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableOutboxUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's following collection with the given
+  * identifier.  It works the same as {@link Context.getPortableFollowingUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The following collection's portable ID.
+  * @throws {RouterError} If no following collection is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableFollowingUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's followers collection with the given
+  * identifier.  It works the same as {@link Context.getPortableFollowersUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The followers collection's portable ID.
+  * @throws {RouterError} If no followers collection is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableFollowersUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's liked collection with the given
+  * identifier.  It works the same as {@link Context.getPortableLikedUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The liked collection's portable ID.
+  * @throws {RouterError} If no liked collection is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableLikedUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's featured collection with the given
+  * identifier.  It works the same as {@link Context.getPortableFeaturedUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The featured collection's portable ID.
+  * @throws {RouterError} If no featured collection is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableFeaturedUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of an actor's featured tags collection with the given
+  * identifier.  It works the same as {@link Context.getPortableFeaturedTagsUri}, except that
+  * the authority can be omitted while handling a portable gateway request.
+  * In that case, the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param identifier The actor's identifier.
+  * @param authority The DID that controls the actor, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The featured tags collection's portable ID.
+  * @throws {RouterError} If no featured tags collection is available.
+  * @throws {TypeError} If the authority is not a DID, it is a `did:key` DID
+  *                     that is not encoded in base58-btc, or the authority
+  *                     is omitted outside a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableFeaturedTagsUri(identifier: string, authority?: string): URL;
+  /**
+  * Builds the [FEP-ef61] portable ID of a custom collection with the given
+  * name and values.  It works the same as
+  * {@link Context.getPortableCollectionUri}, except that the authority can
+  * be omitted while handling a portable gateway request.  In that case,
+  * the DID in {@link RequestContext.portableRequest} is used.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param name The name of the collection, which can be a string or a symbol.
+  * @param values The values of the URI parameters.
+  * @param authority The DID that controls the collection, e.g.,
+  *                  `did:key:z6Mk...`.  Defaults to the DID of the requested
+  *                  portable object or collection.
+  * @returns The collection's portable ID.
+  * @throws {RouterError} If no collection dispatcher is available for
+  *                       the name.
+  * @throws {TypeError} If values are invalid, the authority is not a DID,
+  *                     it is a `did:key` DID that is not encoded in
+  *                     base58-btc, or the authority is omitted outside
+  *                     a portable gateway request.
+  * @since 2.4.0
+  */
+  getPortableCollectionUri<TParam extends Record<string, string>>(name: string | symbol, values: TParam, authority?: string): URL;
+  /**
   * Creates a new context with the same properties as this one,
   * but with the given data.
   * @param data The new data to associate with the context.
@@ -2837,13 +4226,62 @@ interface RequestContext<TContextData> extends Context<TContextData> {
   * @param cls The class to instantiate.
   * @param values The values to pass to the object dispatcher.
   * @returns The object of the given class with the given values, or `null`
-  *          if the object is not found.
+  *          if the object is not found.  Tombstoned objects are suppressed
+  *          unless the tombstone is an instance of `cls`.
   * @throws {Error} If no object dispatcher is available for the class.
   * @throws {TypeError} If values are invalid.
   * @since 0.7.0
   */
   getObject<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>): Promise<TObject | null>;
   /**
+  * Gets an object of the given class, or a {@link Tombstone}, with the given
+  * values.
+  * @param cls The class to instantiate.
+  * @param values The values to pass to the object dispatcher.
+  * @param options Options for getting the object.  Set `options.tombstone`
+  *                to `"passthrough"` to receive tombstoned objects instead
+  *                of `null`.
+  * @returns The object of the given class with the given values,
+  *          a tombstone, or `null` if the object is not found.
+  * @throws {Error} If no object dispatcher is available for the class.
+  * @throws {TypeError} If values are invalid.
+  * @since 2.4.0
+  */
+  getObject<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>, options: GetObjectOptions & {
+    readonly tombstone: "passthrough";
+  }): Promise<TObject | Tombstone | null>;
+  /**
+  * Gets an object of the given class with the given values.
+  * @param cls The class to instantiate.
+  * @param values The values to pass to the object dispatcher.
+  * @param options Options for getting the object.
+  * @returns The object of the given class with the given values, or `null`
+  *          if the object is not found.  Tombstoned objects are suppressed
+  *          unless `options.tombstone` is `"passthrough"` or the tombstone
+  *          is an instance of `cls`.
+  * @throws {Error} If no object dispatcher is available for the class.
+  * @throws {TypeError} If values are invalid.
+  * @since 2.4.0
+  */
+  getObject<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>, options: GetObjectOptions & {
+    readonly tombstone?: "suppress" | undefined;
+  }): Promise<TObject | null>;
+  /**
+  * Gets an object of the given class, or a {@link Tombstone}, with the given
+  * values.
+  * @param cls The class to instantiate.
+  * @param values The values to pass to the object dispatcher.
+  * @param options Options for getting the object.
+  * @returns The object of the given class with the given values,
+  *          a tombstone, or `null` if the object is not found.  This broad
+  *          overload is used when the caller passes an options value whose
+  *          `tombstone` mode is not known statically.
+  * @throws {Error} If no object dispatcher is available for the class.
+  * @throws {TypeError} If values are invalid.
+  * @since 2.4.0
+  */
+  getObject<TObject extends Object$1>(cls: ConstructorWithTypeId<TObject>, values: Record<string, string>, options: GetObjectOptions): Promise<TObject | Tombstone | null>;
+  /**
   * Gets the public key of the sender, if any exists and it is verified.
   * Otherwise, `null` is returned.
   *
@@ -2909,6 +4347,52 @@ interface RequestContext<TContextData> extends Context<TContextData> {
   * [instance actor]: https://swicg.github.io/activitypub-http-signature/#instance-actor
   */
   getSignedKeyOwner(options: GetKeyOwnerOptions): Promise<Actor | null>;
+  /**
+  * Checks whether the request is signed by an actor who belongs to
+  * the intended audience of an object, i.e., the owner of the signed key
+  * (see {@link RequestContext.getSignedKeyOwner}) is one of the object's
+  * `to`, `cc`, `bto`, `bcc`, and `audience`, or a member of one of them
+  * according to the `isMember` option.
+  *
+  * Everyone belongs to the audience of a publicly addressed object, so it
+  * returns `true` for such an object even if the request is not signed.
+  *
+  * This can be used in authorization predicates for serving non-public
+  * objects, which [FEP-ef61] requires of gateways serving portable objects.
+  * [FEP-ef61] portable IDs are compared by their canonical forms, so
+  * an `ap:` URI, an `ap+ef61:` URI, and a compatible identifier on any
+  * gateway refer to the same actor.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  *
+  * @param object The object whose audience is checked.
+  * @param options Options for checking the audience.
+  * @returns `true` if the object is publicly addressed, or the request is
+  *          signed by an actor who belongs to its audience.
+  * @since 2.4.0
+  */
+  isSignedByAudience(object: Object$1, options?: IsSignedByAudienceOptions): Promise<boolean>;
+}
+/**
+* Options for {@link RequestContext.isSignedByAudience} method.
+* @since 2.4.0
+*/
+interface IsSignedByAudienceOptions extends GetKeyOwnerOptions {
+  /**
+  * Checks whether the actor who signed the request is a member of
+  * an addressee of the object that is not the actor itself, e.g.,
+  * a followers collection.  Fedify does not resolve collections by itself,
+  * as only the application can tell their members reliably.
+  *
+  * It is called for each such addressee in order until it returns `true`.
+  * If it is omitted, only the actors that the object addresses directly
+  * belong to its audience.
+  * @param addressee The ID of the addressee, e.g., the ID of a followers
+  *                  collection.
+  * @param actor The actor who signed the request.
+  * @returns `true` if the actor is a member of the addressee.
+  */
+  isMember?: (addressee: URL, actor: Actor) => boolean | Promise<boolean>;
 }
 /**
 * A context for inbox listeners.
@@ -3038,52 +4522,143 @@ interface OutboxContext<TContextData> extends Context<TContextData> {
   clone(data: TContextData): OutboxContext<TContextData>;
 }
 /**
+* Options for {@link Context.parseUri}.
+* @since 2.4.0
+*/
+interface ParseUriOptions {
+  /**
+  * Whether to also recognize [FEP-ef61] portable IDs, i.e., `ap:` and
+  * `ap+ef61:` URIs, and their compatible identifiers on any gateway.
+  * The result of a portable ID has its DID, without percent-encoding, in
+  * the `authority` property, which the caller has to compare with the DID
+  * that it stores for the actor or object, since anyone can make a portable
+  * ID with the same path under another DID.
+  *
+  * Like URIs on this server's origin, a portable ID is recognized by its
+  * path, and its query, e.g., location hints, and fragment are ignored.
+  * A shared inbox is never recognized in a portable ID, and a portable ID
+  * with a malformed DID, or with a `did:key` DID that is not encoded in
+  * base58-btc, is not recognized either.
+  *
+  * [FEP-ef61]: https://w3id.org/fep/ef61
+  * @default `false`
+  */
+  readonly portable?: boolean;
+}
+/**
 * A result of parsing an URI.
 */
 type ParseUriResult = {
   readonly type: "actor";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "object";
   readonly class: ConstructorWithTypeId<Object$1>;
   readonly typeId: URL;
   readonly values: Record<string, string>;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "inbox";
   readonly identifier: undefined;
+  readonly authority?: undefined;
 } | {
   readonly type: "inbox";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "outbox";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "following";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "followers";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "liked";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "featured";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "featuredTags";
   readonly identifier: string;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "collection";
   readonly name: string | symbol;
   readonly class: ConstructorWithTypeId<Object$1>;
   readonly typeId: URL;
   readonly values: Record<string, string>;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 } | {
   readonly type: "orderedCollection";
   readonly name: string | symbol;
   readonly class: ConstructorWithTypeId<Object$1>;
   readonly typeId: URL;
   readonly values: Record<string, string>;
+  /**
+  * The DID of the portable ID, e.g., `did:key:z6Mk...`, or `undefined`
+  * for a URI on this server's origin.  See {@link ParseUriOptions.portable}.
+  * @since 2.4.0
+  */
+  readonly authority?: string;
 };
 /**
 * Options for {@link Context.sendActivity} method.
@@ -3250,4 +4825,4 @@ interface ActorKeyPair extends CryptoKeyPair {
   readonly multikey: Multikey;
 }
 //#endregion
-export { CircuitBreakerCreateOptions as $, OutboxListenerSetters as A, UnverifiedActivityHandler as At, TaskEnqueueOptions as B, FederationStartQueueOptions as C, ObjectAuthorizePredicate as Ct, InboxListenerSetters as D, OutboxListenerErrorHandler as Dt, InboxChallengePolicy as E, OutboxListener as Et, createFederation as F, PageItems as Ft, RetryPolicy as G, TaskRegistry as H, Message as I, buildCollectionSynchronizationHeader as It, respondWithObject as J, createExponentialBackoffPolicy as K, createFederationBuilder as L, digest as Lt, FederationKvPrefixes as M, WebFingerLinksDispatcher as Mt, FederationOrigin as N, SendActivityError as Nt, MediaUploaderSetters as O, OutboxPermanentFailureHandler as Ot, FederationQueueOptions as P, SenderKeyPair as Pt, CircuitBreakerBeforeSendDecision as Q, TaskDefinition as R, ActivityTransformer as Rt, FederationOptions as S, NodeInfoDispatcher as St, IdempotencyStrategy as T, OutboxErrorHandler as Tt, CreateExponentialBackoffPolicyOptions as U, TaskHandler as V, RetryContext as W, CircuitBreaker as X, respondWithObjectIfAcceptable as Y, CircuitBreakerActivityDrop as Z, Federatable as _, CustomCollectionCursor as _t, GetSignedKeyOptions as a, NormalizedCircuitBreakerOptions as at, FederationBuilder as b, InboxListener as bt, ParseUriResult as c, ActorAliasMapper as ct, SendActivityOptions as d, ActorKeyPairsDispatcher as dt, CircuitBreakerFailurePolicy as et, SendActivityOptionsForCollection as f, AuthorizePredicate as ft, CustomCollectionCallbackSetters as g, CustomCollectionCounter as gt, ConstructorWithTypeId as h, CollectionDispatcher as ht, GetActorOptions as i, CircuitBreakerStateChange as it, Rfc6570Expression as j, UnverifiedActivityReason as jt, ObjectCallbackSetters as k, SharedInboxKeyDispatcher as kt, RequestContext as l, ActorDispatcher as lt, CollectionCallbackSetters as m, CollectionCursor as mt, Context as n, CircuitBreakerOptions as nt, InboxContext as o, normalizeCircuitBreakerOptions as ot, ActorCallbackSetters as p, CollectionCounter as pt, RespondWithObjectOptions as q, ForwardActivityOptions as r, CircuitBreakerState as rt, OutboxContext as s, parseCircuitBreakerKvState as st, ActorKeyPair as t, CircuitBreakerKvState as tt, RouteActivityOptions as u, ActorHandleMapper as ut, Federation as v, CustomCollectionDispatcher as vt, IdempotencyKeyCallback as w, ObjectDispatcher as wt, FederationFetchOptions as x, MediaUploaderCallback as xt, FederationBenchmarkOptions as y, InboxErrorHandler as yt, TaskDefinitionOptions as z };
+export { respondWithObject as $, digest as $t, InboxChallengePolicy as A, CustomCollectionDispatcher as At, createFederation as B, OutboxListener as Bt, FederationBenchmarkOptions as C, ActorKeyPairsDispatcher as Ct, FederationStartQueueOptions as D, CollectionDispatcher as Dt, FederationOptions as E, CollectionCursor as Et, PortableInboxForwardingOptions as F, MediaUploaderCallback as Ft, TaskEnqueueOptions as G, SharedInboxKeyDispatcher as Gt, createFederationBuilder as H, OutboxPermanentFailureHandler as Ht, Rfc6570Expression as I, NodeInfoDispatcher as It, CreateExponentialBackoffPolicyOptions as J, WebFingerLinksDispatcher as Jt, TaskHandler as K, UnverifiedActivityHandler as Kt, FederationKvPrefixes as L, ObjectAuthorizePredicate as Lt, MediaUploaderSetters as M, HashlinkMediaRequest as Mt, ObjectCallbackSetters as N, InboxErrorHandler as Nt, IdempotencyKeyCallback as O, CustomCollectionCounter as Ot, OutboxListenerSetters as P, InboxListener as Pt, RespondWithObjectOptions as Q, buildCollectionSynchronizationHeader as Qt, FederationOrigin as R, ObjectDispatcher as Rt, Federation as S, ActorHandleMapper as St, FederationFetchOptions as T, CollectionCounter as Tt, TaskDefinition as U, PortableActorIdMapper as Ut, Message as V, OutboxListenerErrorHandler as Vt, TaskDefinitionOptions as W, PortableCollectionOwnerMapper as Wt, RetryPolicy as X, SenderKeyPair as Xt, RetryContext as Y, SendActivityError as Yt, createExponentialBackoffPolicy as Z, PageItems as Zt, ActorCallbackSetters as _, NormalizedCircuitBreakerOptions as _t, GetObjectOptions as a, InboxRequestReport as an, MessageQueueEnqueueOptions as at, CustomCollectionCallbackSetters as b, ActorAliasMapper as bt, IsSignedByAudienceOptions as c, CircuitBreaker as ct, ParseUriResult as d, CircuitBreakerCreateOptions as dt, ActivityTransformer as en, respondWithObjectIfAcceptable as et, PortableRequest as f, CircuitBreakerFailurePolicy as ft, SendActivityOptionsForCollection as g, CircuitBreakerStateChange as gt, SendActivityOptions as h, CircuitBreakerState as ht, GetActorOptions as i, InboxRequestOutcome as in, MessageQueueDepth as it, InboxListenerSetters as j, HashlinkMediaDispatcher as jt, IdempotencyStrategy as k, CustomCollectionCursor as kt, OutboxContext as l, CircuitBreakerActivityDrop as lt, RouteActivityOptions as m, CircuitBreakerOptions as mt, Context as n, InboxJsonValue as nn, InProcessMessageQueueOptions as nt, GetSignedKeyOptions as o, MessageQueueListenOptions as ot, RequestContext as p, CircuitBreakerKvState as pt, TaskRegistry as q, UnverifiedActivityReason as qt, ForwardActivityOptions as r, InboxRequestFinishedHandler as rn, MessageQueue as rt, InboxContext as s, ParallelMessageQueue as st, ActorKeyPair as t, InboxAuthentication as tn, InProcessMessageQueue as tt, ParseUriOptions as u, CircuitBreakerBeforeSendDecision as ut, CollectionCallbackSetters as v, normalizeCircuitBreakerOptions as vt, FederationBuilder as w, AuthorizePredicate as wt, Federatable as x, ActorDispatcher as xt, ConstructorWithTypeId as y, parseCircuitBreakerKvState as yt, FederationQueueOptions as z, OutboxErrorHandler as zt };