@fedify/fedify 2.0.0-pr.490.2 → 2.0.0-pr.559.4

package/dist/{context-V-XS2_6O.d.ts → context-CJaICYPw.d.ts}

@@ -1,15 +1,13 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { GetNodeInfoOptions, JsonValue, NodeInfo } from "./client-BsGzbnV-.js";
-import { Activity, Collection, CryptographicKey, Hashtag, Link, Multikey, Object as Object$1 } from "./vocab-BCWe1Ih5.js";
-import { Actor, Recipient } from "./actor-DqFajh9s.js";
-import { HttpMessageSignaturesSpec } from "./http-BbO0ejuk.js";
-import { GetKeyOwnerOptions } from "./owner-kQRGVXG1.js";
-import { LookupObjectOptions, TraverseCollectionOptions } from "./mod-BlVovdcy.js";
-import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "./mod-Ds0mpFZU.js";
-import { KvKey, KvStore } from "./kv-BKNZ-Tb-.js";
-import { Span, TracerProvider } from "@opentelemetry/api";
+import { GetNodeInfoOptions, JsonValue, NodeInfo } from "./client-CUTUGgvJ.js";
+import { HttpMessageSignaturesSpec } from "./http-DLBDPal9.js";
+import { GetKeyOwnerOptions } from "./owner-BgI8C-VY.js";
+import { KvKey, KvStore } from "./kv-CYySNrsn.js";
+import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Object as Object$1, Recipient, TraverseCollectionOptions } from "@fedify/vocab";
+import { Span, Tracer, TracerProvider } from "@opentelemetry/api";
 import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions } from "@fedify/vocab-runtime";
+import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 
 //#region src/compat/types.d.ts
 /**
@@ -23,9 +21,9 @@ type ActivityTransformer<TContextData> = (activity: Activity, context: Context<T
  * A page of items.
  */
 interface PageItems<TItem> {
-  prevCursor?: string | null;
-  nextCursor?: string | null;
-  items: TItem[];
+  readonly prevCursor?: string | null;
+  readonly nextCursor?: string | null;
+  readonly items: readonly TItem[];
 }
 /**
  * Calculates the [partial follower collection digest][1].
@@ -55,15 +53,44 @@ interface SenderKeyPair {
   /**
    * The actor's private key to sign the request.
    */
-  privateKey: CryptoKey;
+  readonly privateKey: CryptoKey;
   /**
    * The public key ID that corresponds to the private key.
    */
-  keyId: URL;
+  readonly keyId: URL;
 }
 /**
  * Parameters for {@link sendActivity}.
  */
+
+/**
+ * An error that is thrown when an activity fails to send to a remote inbox.
+ * It contains structured information about the failure, including the HTTP
+ * status code, the inbox URL, and the response body.
+ * @since 2.0.0
+ */
+declare class SendActivityError extends Error {
+  /**
+   * The inbox URL that the activity was being sent to.
+   */
+  readonly inbox: URL;
+  /**
+   * The HTTP status code returned by the inbox.
+   */
+  readonly statusCode: number;
+  /**
+   * The response body from the inbox, if any.
+   */
+  readonly responseBody: string;
+  /**
+   * Creates a new {@link SendActivityError}.
+   * @param inbox The inbox URL.
+   * @param statusCode The HTTP status code.
+   * @param message The error message.
+   * @param responseBody The response body.
+   */
+  constructor(inbox: URL, statusCode: number, message: string, responseBody: string);
+}
 //#endregion
 //#region src/federation/callback.d.ts
 /**
@@ -226,6 +253,40 @@ type SharedInboxKeyDispatcher<TContextData> = (context: Context<TContextData>) =
  * @since 0.6.0
  */
 type OutboxErrorHandler = (error: Error, activity: Activity | null) => void | Promise<void>;
+/**
+ * A callback that handles permanent delivery failures when sending activities
+ * to remote inboxes.
+ *
+ * This handler is called when an inbox returns an HTTP status code that
+ * indicates permanent failure (such as `410 Gone` or `404 Not Found`),
+ * allowing the application to clean up followers that are no longer reachable.
+ *
+ * Unlike {@link OutboxErrorHandler}, which is called for every delivery failure
+ * (including retries), this handler is called only once for permanent failures,
+ * after which delivery is not retried.
+ *
+ * If any errors are thrown in this callback, they are caught, logged,
+ * and ignored.
+ *
+ * @template TContextData The context data to pass to the {@link Context}.
+ * @param context The context.
+ * @param values The delivery failure information.
+ * @since 2.0.0
+ */
+type OutboxPermanentFailureHandler<TContextData> = (context: Context<TContextData>, values: {
+  /** The inbox URL that failed. */
+  readonly inbox: URL;
+  /** The activity that failed to deliver. */
+  readonly activity: Activity;
+  /** The error that occurred. */
+  readonly error: SendActivityError;
+  /** The HTTP status code returned by the inbox. */
+  readonly statusCode: number;
+  /**
+   * The actor IDs that were supposed to receive the activity at this inbox.
+   */
+  readonly actorIds: readonly URL[];
+}) => void | Promise<void>;
 /**
  * A callback that determines if a request is authorized or not.
  *
@@ -319,7 +380,19 @@ interface MessageQueueEnqueueOptions {
    *
    * It must not be negative.
    */
-  delay?: Temporal.Duration;
+  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;
 }
 /**
  * Additional options for listening to a message queue.
@@ -362,7 +435,7 @@ interface MessageQueue {
    * @param messages The messages to enqueue.
    * @param options Additional options for enqueuing the messages.
    */
-  enqueueMany?: (messages: any[], options?: MessageQueueEnqueueOptions) => Promise<void>;
+  enqueueMany?: (messages: readonly any[], options?: MessageQueueEnqueueOptions) => Promise<void>;
   /**
    * Listens for messages in the queue.
    * @param handler The handler for messages in the queue.
@@ -404,7 +477,7 @@ declare class InProcessMessageQueue implements MessageQueue {
    */
   constructor(options?: InProcessMessageQueueOptions);
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
-  enqueueMany(messages: any[], options?: MessageQueueEnqueueOptions): Promise<void>;
+  enqueueMany(messages: readonly any[], options?: MessageQueueEnqueueOptions): Promise<void>;
   listen(handler: (message: any) => Promise<void> | void, options?: MessageQueueListenOptions): Promise<void>;
 }
 /**
@@ -420,6 +493,21 @@ declare class InProcessMessageQueue implements MessageQueue {
  * 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 {
@@ -442,7 +530,7 @@ declare class ParallelMessageQueue implements MessageQueue {
    */
   constructor(queue: MessageQueue, workers: number);
   enqueue(message: any, options?: MessageQueueEnqueueOptions): Promise<void>;
-  enqueueMany(messages: 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
@@ -573,8 +661,8 @@ declare function createFederationBuilder<TContextData>(): FederationBuilder<TCon
 //#endregion
 //#region src/federation/queue.d.ts
 interface SenderKeyJwkPair {
-  keyId: string;
-  privateKey: JsonWebKey;
+  readonly keyId: string;
+  readonly privateKey: JsonWebKey;
 }
 /**
  * A message that represents a task to be processed by the background worker.
@@ -587,44 +675,47 @@ interface SenderKeyJwkPair {
  */
 type Message = FanoutMessage | OutboxMessage | InboxMessage;
 interface FanoutMessage {
-  type: "fanout";
-  id: ReturnType<typeof crypto.randomUUID>;
-  baseUrl: string;
-  keys: SenderKeyJwkPair[];
-  inboxes: Record<string, {
-    actorIds: string[];
-    sharedInbox: boolean;
-  }>;
-  activity: unknown;
-  activityId?: string;
-  activityType: string;
-  collectionSync?: string;
-  traceContext: Record<string, string>;
+  readonly type: "fanout";
+  readonly id: ReturnType<typeof crypto.randomUUID>;
+  readonly baseUrl: string;
+  readonly keys: readonly SenderKeyJwkPair[];
+  readonly inboxes: Readonly<Record<string, {
+    readonly actorIds: readonly string[];
+    readonly sharedInbox: boolean;
+  }>>;
+  readonly activity: unknown;
+  readonly activityId?: string;
+  readonly activityType: string;
+  readonly collectionSync?: string;
+  readonly orderingKey?: string;
+  readonly traceContext: Readonly<Record<string, string>>;
 }
 interface OutboxMessage {
-  type: "outbox";
-  id: ReturnType<typeof crypto.randomUUID>;
-  baseUrl: string;
-  keys: SenderKeyJwkPair[];
-  activity: unknown;
-  activityId?: string;
-  activityType: string;
-  inbox: string;
-  sharedInbox: boolean;
-  started: string;
-  attempt: number;
-  headers: Record<string, string>;
-  traceContext: Record<string, string>;
+  readonly type: "outbox";
+  readonly id: ReturnType<typeof crypto.randomUUID>;
+  readonly baseUrl: string;
+  readonly keys: readonly SenderKeyJwkPair[];
+  readonly activity: unknown;
+  readonly activityId?: string;
+  readonly activityType: string;
+  readonly inbox: string;
+  readonly sharedInbox: boolean;
+  readonly actorIds?: readonly string[];
+  readonly started: string;
+  readonly attempt: number;
+  readonly headers: Readonly<Record<string, string>>;
+  readonly orderingKey?: string;
+  readonly traceContext: Readonly<Record<string, string>>;
 }
 interface InboxMessage {
-  type: "inbox";
-  id: ReturnType<typeof crypto.randomUUID>;
-  baseUrl: string;
-  activity: unknown;
-  started: string;
-  attempt: number;
-  identifier: string | null;
-  traceContext: Record<string, string>;
+  readonly type: "inbox";
+  readonly id: ReturnType<typeof crypto.randomUUID>;
+  readonly baseUrl: string;
+  readonly activity: unknown;
+  readonly started: string;
+  readonly attempt: number;
+  readonly identifier: string | null;
+  readonly traceContext: Readonly<Record<string, string>>;
 }
 //#endregion
 //#region src/federation/retry.d.ts
@@ -708,19 +799,19 @@ interface FederationQueueOptions {
    * The message queue for incoming activities.  If not provided, incoming
    * activities will not be queued and will be processed immediately.
    */
-  inbox?: MessageQueue;
+  readonly inbox?: MessageQueue;
   /**
    * The message queue for outgoing activities.  If not provided, outgoing
    * activities will not be queued and will be sent immediately.
    */
-  outbox?: MessageQueue;
+  readonly outbox?: MessageQueue;
   /**
    * The message queue for fanning out outgoing activities.  If not provided,
    * outgoing activities will not be fanned out in the background, but will be
    * fanned out immediately, which causes slow response times on
    * {@link Context.sendActivity} calls.
    */
-  fanout?: MessageQueue;
+  readonly fanout?: MessageQueue;
 }
 /**
  * Prefixes for namespacing keys in the Deno KV store.
@@ -731,18 +822,18 @@ interface FederationKvPrefixes {
    * processed or not.
    * @default `["_fedify", "activityIdempotence"]`
    */
-  activityIdempotence: KvKey;
+  readonly activityIdempotence: KvKey;
   /**
    * The key prefix used for storing remote JSON-LD documents.
    * @default `["_fedify", "remoteDocument"]`
    */
-  remoteDocument: KvKey;
+  readonly remoteDocument: KvKey;
   /**
    * The key prefix used for caching public keys.
    * @default `["_fedify", "publicKey"]`
    * @since 0.12.0
    */
-  publicKey: KvKey;
+  readonly publicKey: KvKey;
   /**
    * The key prefix used for caching HTTP Message Signatures specs.
    * The cached spec is used to reduce the number of requests to make signed
@@ -750,7 +841,7 @@ interface FederationKvPrefixes {
    * @default `["_fedify", "httpMessageSignaturesSpec"]`
    * @since 1.6.0
    */
-  httpMessageSignaturesSpec: KvKey;
+  readonly httpMessageSignaturesSpec: KvKey;
 }
 /**
  * Options for {@link CreateFederationOptions.origin} when it is not a string.
@@ -1049,7 +1140,7 @@ interface Federatable<TContextData> {
    *                        ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
    *                        The path must have no variables.
    * @returns An object to register inbox listeners.
-   * @throws {RouteError} Thrown if the path pattern is invalid.
+   * @throws {RouterError} Thrown if the path pattern is invalid.
    */
   setInboxListeners(inboxPath: `${string}${Rfc6570Expression<"identifier">}${string}` | `${string}${Rfc6570Expression<"handle">}${string}`, sharedInboxPath?: string): InboxListenerSetters<TContextData>;
   /**
@@ -1142,6 +1233,22 @@ interface Federatable<TContextData> {
    * @param dispatcher A collection dispatcher callback to register.
    */
   setOrderedCollectionDispatcher<TObject extends Object$1, TParam extends string>(name: string | symbol, itemType: ConstructorWithTypeId<TObject>, path: `${string}${Rfc6570Expression<TParam>}${string}`, dispatcher: CustomCollectionDispatcher<TObject, TParam, RequestContext<TContextData>, TContextData>): CustomCollectionCallbackSetters<TParam, RequestContext<TContextData>, TContextData>;
+  /**
+   * Registers a handler for permanent delivery failures.
+   *
+   * This handler is called when an inbox returns an HTTP status code
+   * that indicates permanent failure (`410 Gone`, `404 Not Found`, etc.),
+   * allowing the application to clean up followers that are no longer
+   * reachable.
+   *
+   * Unlike `onOutboxError`, which is called for every delivery failure
+   * (including retries), this handler is called only once for permanent
+   * failures, after which delivery is not retried.
+   *
+   * @param handler A callback to handle permanent failures.
+   * @since 2.0.0
+   */
+  setOutboxPermanentFailureHandler(handler: OutboxPermanentFailureHandler<TContextData>): void;
 }
 /**
  * An object that registers federation-related business logic and dispatches
@@ -1314,6 +1421,17 @@ interface FederationOptions<TContextData> {
    * If any errors are thrown in this callback, they are ignored.
    */
   onOutboxError?: OutboxErrorHandler;
+  /**
+   * HTTP status codes that should be treated as permanent delivery failures.
+   * When an inbox returns one of these codes, the delivery will not be retried
+   * and the permanent failure handler (if registered via
+   * {@link Federatable.setOutboxPermanentFailureHandler}) will be called.
+   *
+   * By default, `[404, 410]`.
+   *
+   * @since 2.0.0
+   */
+  permanentFailureStatusCodes?: readonly number[];
   /**
    * The time window for verifying HTTP Signatures of incoming requests.  If the
    * request is older or newer than this window, it is rejected.  Or if it is
@@ -1768,7 +1886,7 @@ interface Context<TContextData> {
    * @param cls The class of the object.
    * @param values The values to pass to the object dispatcher.
    * @returns The object's URI.
-   * @throws {RouteError} If no object dispatcher is available for the class.
+   * @throws {RouterError} If no object dispatcher is available for the class.
    * @throws {TypeError} If values are invalid.
    * @since 0.7.0
    */
@@ -2000,7 +2118,7 @@ interface Context<TContextData> {
     handle: string;
   }, recipients: Recipient | Recipient[], activity: Activity, options?: SendActivityOptions): Promise<void>;
   /**
-   * Sends an activity to the outboxes of the sender's followers.
+   * Sends an activity to the inboxes of the sender's followers.
    * @param sender The sender's identifier or the sender's username.
    * @param recipients In this case, it must be `"followers"`.
    * @param activity The activity to send.
@@ -2041,7 +2159,7 @@ interface Context<TContextData> {
    * @param name The name of the collection, which can be a string or a symbol.
    * @param values The values of the URI parameters.
    * @return The URI of the collection.
-   * @throws {RouteError} If no object dispatcher is available for the name.
+   * @throws {RouterError} If no object dispatcher is available for the name.
    * @throws {TypeError} If values are invalid.
    * @since 1.8.0
    */
@@ -2164,7 +2282,7 @@ interface InboxContext<TContextData> extends Context<TContextData> {
    * inbox, it is `null`.
    * @since 1.2.0
    */
-  recipient: string | null;
+  readonly recipient: string | null;
   /**
    * Creates a new context with the same properties as this one,
    * but with the given data.
@@ -2320,7 +2438,7 @@ interface SendActivityOptions {
   /**
    * Whether to prefer the shared inbox for the recipients.
    */
-  preferSharedInbox?: boolean;
+  readonly preferSharedInbox?: boolean;
   /**
    * Whether to send the activity immediately, without enqueuing it.
    * If `true`, the activity will be sent immediately and the retrial
@@ -2328,7 +2446,7 @@ interface SendActivityOptions {
    *
    * @since 0.3.0
    */
-  immediate?: boolean;
+  readonly immediate?: boolean;
   /**
    * Determines how activities are queued when sent to multiple recipients.
    *
@@ -2345,7 +2463,7 @@ interface SendActivityOptions {
    * @default `"auto"`
    * @since 1.5.0
    */
-  fanout?: "auto" | "skip" | "force";
+  readonly fanout?: "auto" | "skip" | "force";
   /**
    * The base URIs to exclude from the recipients' inboxes.  It is useful
    * for excluding the recipients having the same shared inbox with the sender.
@@ -2354,7 +2472,21 @@ interface SendActivityOptions {
    *
    * @since 0.9.0
    */
-  excludeBaseUris?: URL[];
+  readonly excludeBaseUris?: readonly URL[];
+  /**
+   * An optional key to ensure ordered delivery of activities.  Activities with
+   * the same `orderingKey` are guaranteed to be delivered in the order they
+   * were enqueued, per recipient server.
+   *
+   * Typical use case: pass the object ID (e.g., `Note` ID) to ensure that
+   * `Create`, `Update`, and `Delete` activities for the same object are
+   * delivered in order.
+   *
+   * When omitted, no ordering is guaranteed (maximum parallelism).
+   *
+   * @since 2.0.0
+   */
+  readonly orderingKey?: string;
 }
 /**
  * Options for {@link Context.sendActivity} method when sending to a collection.
@@ -2437,15 +2569,15 @@ interface ActorKeyPair extends CryptoKeyPair {
   /**
    * The URI of the public key, which is used for verifying HTTP Signatures.
    */
-  keyId: URL;
+  readonly keyId: URL;
   /**
    * A {@link CryptographicKey} instance of the public key.
    */
-  cryptographicKey: CryptographicKey;
+  readonly cryptographicKey: CryptographicKey;
   /**
    * A {@link Multikey} instance of the public key.
    */
-  multikey: Multikey;
+  readonly multikey: Multikey;
 }
 //#endregion
-export { ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateFederationOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, ForwardActivityOptions, GetSignedKeyOptions, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfoDispatcher, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboxErrorHandler, PageItems, ParallelMessageQueue, ParseUriResult, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, SharedInboxKeyDispatcher, WebFingerLinksDispatcher, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, respondWithObject, respondWithObjectIfAcceptable };
+export { ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateFederationOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, ForwardActivityOptions, GetSignedKeyOptions, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, Message, MessageQueue, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfoDispatcher, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboxErrorHandler, OutboxPermanentFailureHandler, PageItems, ParallelMessageQueue, ParseUriResult, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityError, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, SharedInboxKeyDispatcher, WebFingerLinksDispatcher, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, digest, respondWithObject, respondWithObjectIfAcceptable };

package/dist/context-CZ5llAss.js

@@ -0,0 +1,109 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { mockDocumentLoader } from "./dist-B5f6a8Tt.js";
+import { RouterError } from "./router-D9eI0s4b.js";
+import { lookupObject, traverseCollection } from "@fedify/vocab";
+import { lookupWebFinger } from "@fedify/webfinger";
+import { trace } from "@opentelemetry/api";
+
+//#region src/testing/context.ts
+function createContext(values) {
+	const { federation, url = new URL("http://example.com/"), canonicalOrigin, data, documentLoader, contextLoader, tracerProvider, clone, getNodeInfoUri, getActorUri, getObjectUri, getCollectionUri, getOutboxUri, getInboxUri, getFollowingUri, getFollowersUri, getLikedUri, getFeaturedUri, getFeaturedTagsUri, parseUri, getActorKeyPairs, getDocumentLoader, lookupObject: lookupObject$1, traverseCollection: traverseCollection$1, lookupNodeInfo, lookupWebFinger: lookupWebFinger$1, sendActivity, routeActivity } = values;
+	function throwRouterError() {
+		throw new RouterError("Not implemented");
+	}
+	return {
+		federation,
+		data,
+		origin: url.origin,
+		canonicalOrigin: canonicalOrigin ?? url.origin,
+		host: url.host,
+		hostname: url.hostname,
+		documentLoader: documentLoader ?? mockDocumentLoader,
+		contextLoader: contextLoader ?? mockDocumentLoader,
+		tracerProvider: tracerProvider ?? trace.getTracerProvider(),
+		clone: clone ?? ((data$1) => createContext({
+			...values,
+			data: data$1
+		})),
+		getNodeInfoUri: getNodeInfoUri ?? throwRouterError,
+		getActorUri: getActorUri ?? throwRouterError,
+		getObjectUri: getObjectUri ?? throwRouterError,
+		getCollectionUri: getCollectionUri ?? throwRouterError,
+		getOutboxUri: getOutboxUri ?? throwRouterError,
+		getInboxUri: getInboxUri ?? throwRouterError,
+		getFollowingUri: getFollowingUri ?? throwRouterError,
+		getFollowersUri: getFollowersUri ?? throwRouterError,
+		getLikedUri: getLikedUri ?? throwRouterError,
+		getFeaturedUri: getFeaturedUri ?? throwRouterError,
+		getFeaturedTagsUri: getFeaturedTagsUri ?? throwRouterError,
+		parseUri: parseUri ?? ((_uri) => {
+			throw new Error("Not implemented");
+		}),
+		getDocumentLoader: getDocumentLoader ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		getActorKeyPairs: getActorKeyPairs ?? ((_handle) => Promise.resolve([])),
+		lookupObject: lookupObject$1 ?? ((uri, options = {}) => {
+			return lookupObject(uri, {
+				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
+				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
+			});
+		}),
+		traverseCollection: traverseCollection$1 ?? ((collection, options = {}) => {
+			return traverseCollection(collection, {
+				documentLoader: options.documentLoader ?? documentLoader ?? mockDocumentLoader,
+				contextLoader: options.contextLoader ?? contextLoader ?? mockDocumentLoader
+			});
+		}),
+		lookupNodeInfo: lookupNodeInfo ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		lookupWebFinger: lookupWebFinger$1 ?? ((resource, options = {}) => {
+			return lookupWebFinger(resource, options);
+		}),
+		sendActivity: sendActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		}),
+		routeActivity: routeActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+function createRequestContext(args) {
+	return {
+		...createContext(args),
+		clone: args.clone ?? ((data) => createRequestContext({
+			...args,
+			data
+		})),
+		request: args.request ?? new Request(args.url),
+		url: args.url,
+		getActor: args.getActor ?? (() => Promise.resolve(null)),
+		getObject: args.getObject ?? (() => Promise.resolve(null)),
+		getSignedKey: args.getSignedKey ?? (() => Promise.resolve(null)),
+		getSignedKeyOwner: args.getSignedKeyOwner ?? (() => Promise.resolve(null)),
+		sendActivity: args.sendActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+function createInboxContext(args) {
+	return {
+		...createContext(args),
+		clone: args.clone ?? ((data) => createInboxContext({
+			...args,
+			data
+		})),
+		recipient: args.recipient ?? null,
+		forwardActivity: args.forwardActivity ?? ((_params) => {
+			throw new Error("Not implemented");
+		})
+	};
+}
+
+//#endregion
+export { createInboxContext, createRequestContext };