@fedify/fedify 2.4.0-dev.1668 → 2.4.0-dev.1727

package/dist/{context-Cjnr0ig1.d.ts → context-DrLXudbA.d.ts}

@@ -1,9 +1,8 @@
 /// <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-v_e0n5GQ.js";
+import { o as JsonValue, s as NodeInfo, t as GetNodeInfoOptions } from "./client-D-XP_Ccb.js";
+import { o as VerifyRequestFailureReason, t as HttpMessageSignaturesSpec } from "./http-CdrSn2ip.js";
+import { n as GetKeyOwnerOptions } from "./owner-DGSfntI-.js";
+import { n as KvStore, t as KvKey } from "./kv-BhNbN8Ed.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";
@@ -509,6 +508,16 @@ 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 custom policies do not
+  * expire their stored state unless this option is provided.
+  */
+  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 +536,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 +597,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 +610,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 +624,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
@@ -3250,4 +3524,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 { MessageQueueDepth as $, OutboxListenerSetters as A, ObjectAuthorizePredicate as At, TaskEnqueueOptions as B, SendActivityError as Bt, FederationStartQueueOptions as C, CustomCollectionCounter as Ct, InboxListenerSetters as D, InboxListener as Dt, InboxChallengePolicy as E, InboxErrorHandler as Et, createFederation as F, OutboxPermanentFailureHandler as Ft, RetryPolicy as G, ActivityTransformer as Gt, TaskRegistry as H, PageItems as Ht, Message as I, SharedInboxKeyDispatcher as It, respondWithObject as J, createExponentialBackoffPolicy as K, createFederationBuilder as L, UnverifiedActivityHandler as Lt, FederationKvPrefixes as M, OutboxErrorHandler as Mt, FederationOrigin as N, OutboxListener as Nt, MediaUploaderSetters as O, MediaUploaderCallback as Ot, FederationQueueOptions as P, OutboxListenerErrorHandler as Pt, MessageQueue as Q, TaskDefinition as R, UnverifiedActivityReason as Rt, FederationOptions as S, CollectionDispatcher as St, IdempotencyStrategy as T, CustomCollectionDispatcher as Tt, CreateExponentialBackoffPolicyOptions as U, buildCollectionSynchronizationHeader as Ut, TaskHandler as V, SenderKeyPair as Vt, RetryContext as W, digest as Wt, InProcessMessageQueue as X, respondWithObjectIfAcceptable as Y, InProcessMessageQueueOptions as Z, Federatable as _, ActorHandleMapper as _t, GetSignedKeyOptions as a, CircuitBreakerBeforeSendDecision as at, FederationBuilder as b, CollectionCounter as bt, ParseUriResult as c, CircuitBreakerKvState as ct, SendActivityOptions as d, CircuitBreakerStateChange as dt, MessageQueueEnqueueOptions as et, SendActivityOptionsForCollection as f, NormalizedCircuitBreakerOptions as ft, CustomCollectionCallbackSetters as g, ActorDispatcher as gt, ConstructorWithTypeId as h, ActorAliasMapper as ht, GetActorOptions as i, CircuitBreakerActivityDrop as it, Rfc6570Expression as j, ObjectDispatcher as jt, ObjectCallbackSetters as k, NodeInfoDispatcher as kt, RequestContext as l, CircuitBreakerOptions as lt, CollectionCallbackSetters as m, parseCircuitBreakerKvState as mt, Context as n, ParallelMessageQueue as nt, InboxContext as o, CircuitBreakerCreateOptions as ot, ActorCallbackSetters as p, normalizeCircuitBreakerOptions as pt, RespondWithObjectOptions as q, ForwardActivityOptions as r, CircuitBreaker as rt, OutboxContext as s, CircuitBreakerFailurePolicy as st, ActorKeyPair as t, MessageQueueListenOptions as tt, RouteActivityOptions as u, CircuitBreakerState as ut, Federation as v, ActorKeyPairsDispatcher as vt, IdempotencyKeyCallback as w, CustomCollectionCursor as wt, FederationFetchOptions as x, CollectionCursor as xt, FederationBenchmarkOptions as y, AuthorizePredicate as yt, TaskDefinitionOptions as z, WebFingerLinksDispatcher as zt };

package/dist/{deno-DtHcfB0f.mjs → deno-Deyoxesx.mjs}

@@ -3,6 +3,6 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.1668+90797b01";
+var version = "2.4.0-dev.1727+1eadcb04";
 //#endregion
 export { version as n, name as t };

package/dist/{docloader-0vAfF6XW.mjs → docloader-B3kuDBg9.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { o as validateCryptoKey } from "./key-CM7wDnZG.mjs";
-import { n as doubleKnock } from "./http-DUmWq5Pw.mjs";
+import { o as validateCryptoKey } from "./key-b4kf4yZT.mjs";
+import { n as doubleKnock } from "./http-TjhZfiSN.mjs";
 import { getLogger } from "@logtape/logtape";
 import { curry } from "es-toolkit";
 import { UrlError, createActivityPubRequest, getRemoteDocument, logRequest, validatePublicUrl } from "@fedify/vocab-runtime";

package/dist/{esm-yYQfPhIY.mjs → esm-BHXXx4Wx.mjs}

@@ -129,27 +129,27 @@ function parse(input, loose) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/TypeDescriptor.js
-const valueTypes = new Set([
+const valueTypes = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"null",
 	"string",
 	"undefined"
 ]);
-const referenceTypes = new Set([
+const referenceTypes = /* @__PURE__ */ new Set([
 	"array",
 	"function",
 	"object",
 	"symbol"
 ]);
-const detectableTypes = new Set([
+const detectableTypes = /* @__PURE__ */ new Set([
 	"boolean",
 	"function",
 	"number",
 	"string",
 	"symbol"
 ]);
-const typeConstructors = new Set([
+const typeConstructors = /* @__PURE__ */ new Set([
 	Boolean,
 	Number,
 	String
@@ -220,7 +220,7 @@ var TypeDescriptor = class TypeDescriptor {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/fetch-mock@12.6.0/node_modules/fetch-mock/dist/esm/IsSubsetOf.js
-const allowedTypes = new Set([
+const allowedTypes = /* @__PURE__ */ new Set([
 	"array",
 	"object",
 	"function",
@@ -712,7 +712,14 @@ var __classPrivateFieldGet = function(receiver, state, kind, f) {
 	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Route_instances, _a, _Route_responseSubscriptions, _Route_validate, _Route_sanitize, _Route_generateMatcher, _Route_limit, _Route_delayResponse;
+var _Route_instances;
+var _a;
+var _Route_responseSubscriptions;
+var _Route_validate;
+var _Route_sanitize;
+var _Route_generateMatcher;
+var _Route_limit;
+var _Route_delayResponse;
 var RouteConfigWrapper = class {
 	constructor(config) {
 		Object.assign(this, config);

package/dist/federation/builder.test.mjs

@@ -1,11 +1,12 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as MemoryKvStore } from "../kv-CXBAok3k.mjs";
-import { t as assertEquals } from "../assert_equals-BV7oLMxm.mjs";
-import { r as assertExists } from "../std__assert-B2NnY9bq.mjs";
-import { t as assertThrows } from "../assert_throws-NiFfqbnH.mjs";
-import { r as createFederationBuilder } from "../builder-iXZ5jNVg.mjs";
+import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
+import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
+import { t as assertExists } from "../assert_exists-DtzkXC47.mjs";
+import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
+import "../std__assert-CxFT0MNt.mjs";
+import { r as createFederationBuilder } from "../builder-f5-YwHfj.mjs";
 import { DisallowedOperatorError, DisallowedVarSpecModifierError, DuplicateRouteVariableError, RouteTemplateOptionsNotMatchedError, RouterError } from "@fedify/uri-template";
 import { Activity, Note, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
@@ -342,6 +343,18 @@ test("FederationBuilder", async (t) => {
 		});
 		builder.setCollectionDispatcher(strId, Note, "/string-id/{id}", dispatcher);
 	});
+	await t.step("propagates custom collection dispatchers to the built federation", async () => {
+		const kv = new MemoryKvStore();
+		const builder = createFederationBuilder();
+		builder.setCollectionDispatcher("test", Note, "/c/{id}", () => ({ items: [] }));
+		const impl = await builder.build({
+			kv,
+			origin: "https://example.com"
+		});
+		assertExists(impl.collectionCallbacks["test"]);
+		assertEquals(impl.collectionTypeIds["test"], Note);
+		assertEquals((await impl.fetch(new Request("https://example.com/c/x", { headers: { accept: "application/activity+json" } }), { contextData: void 0 })).status, 200);
+	});
 });
 //#endregion
 export {};