@fedify/fedify 1.8.1-pr.315.1091 → 1.8.1-pr.315.1275

package/dist/{middleware-VSdfWI3m.js → middleware-Chh21-S_.js}

@@ -3,32 +3,28 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { deno_default, getDocumentLoader, kvCache } from "./docloader-CJ7eOrpZ.js";
-import { getNodeInfo } from "./client-Cu9HMcIJ.js";
-import { RouterError } from "./router-D3UybECj.js";
-import { nodeInfoToJson } from "./types-C7C_l-jz.js";
-import { Activity, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage } from "./vocab-dw0HG0EQ.js";
-import { lookupWebFinger } from "./lookup-CEbB0_t_.js";
-import { getTypeId } from "./type-D2s5lmbZ.js";
-import { exportJwk, importJwk, validateCryptoKey } from "./key-D9LuuzMv.js";
-import { verifyRequest } from "./http-BigTqmE7.js";
-import { getAuthenticatedDocumentLoader } from "./authdocloader-DUnUXs5R.js";
-import { detachSignature, hasSignature, signJsonLd, verifyJsonLd } from "./ld-CYqXYuyr.js";
-import { doesActorOwnKey, getKeyOwner } from "./owner-D7RvVquY.js";
-import { signObject, verifyObject } from "./proof-D4z1cLgw.js";
-import { lookupObject, traverseCollection } from "./lookup-BYiP0j0F.js";
-import { routeActivity } from "./inbox-BB6ajp8P.js";
-import { FederationBuilderImpl } from "./builder-Js_TKEl1.js";
-import { buildCollectionSynchronizationHeader } from "./collection-Dfb0TPno.js";
-import { KvKeyCache } from "./keycache-C4C7f09E.js";
-import { createExponentialBackoffPolicy } from "./retry-BiIhZWgD.js";
-import { extractInboxes, sendActivity } from "./send-DmlRAY0X.js";
+import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, deno_default, getDocumentLoader, getTypeId, kvCache, lookupWebFinger } from "./type-DHDlfpLg.js";
+import { getNodeInfo } from "./client-Cr3DvU-q.js";
+import { RouterError, lookupObject, traverseCollection } from "./lookup-BGA_VdZm.js";
+import { nodeInfoToJson } from "./types-BIgY6c-l.js";
+import { exportJwk, importJwk, validateCryptoKey } from "./key-B9Yg9Nqz.js";
+import { verifyRequest } from "./http-BkzChfDi.js";
+import { getAuthenticatedDocumentLoader } from "./authdocloader-BkwhwBf_.js";
+import { detachSignature, hasSignature, signJsonLd, verifyJsonLd } from "./ld-i6KANj32.js";
+import { doesActorOwnKey, getKeyOwner } from "./owner-DSr0c3Yp.js";
+import { signObject, verifyObject } from "./proof-B83O-qBN.js";
+import { routeActivity } from "./inbox-CpONbSbQ.js";
+import { FederationBuilderImpl } from "./builder-B-wZuoFJ.js";
+import { buildCollectionSynchronizationHeader } from "./collection-CSzG2j1P.js";
+import { KvKeyCache } from "./keycache-BvyhLLHV.js";
+import { createExponentialBackoffPolicy } from "./retry-D4GJ670a.js";
+import { extractInboxes, sendActivity } from "./send-QRloWueE.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 import { ATTR_HTTP_REQUEST_HEADER, ATTR_HTTP_REQUEST_METHOD, ATTR_HTTP_RESPONSE_HEADER, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_URL_FULL } from "@opentelemetry/semantic-conventions";
 import { domainToASCII } from "node:url";
 
-//#region compat/transformers.ts
+//#region src/compat/transformers.ts
 const logger$1 = getLogger([
 	"fedify",
 	"compat",
@@ -46,7 +42,7 @@ const logger$1 = getLogger([
 * https://example.com/#Follow/12345678-1234-5678-1234-567812345678
 * ```
 *
-* @typeParam TContextData The type of the context data.
+* @template TContextData The type of the context data.
 * @param activity The activity to assign an ID to.
 * @param context The context of the activity.
 * @return The activity with an ID assigned.
@@ -97,7 +93,7 @@ function autoIdAssigner(activity, context$1) {
 *
 * As some ActivityPub implementations like Threads fail to deal with inlined
 * actor objects, this transformer can be used to work around this issue.
-* @typeParam TContextData The type of the context data.
+* @template TContextData The type of the context data.
 * @param activity The activity to dehydrate the actor property of.
 * @param context The context of the activity.
 * @returns The dehydrated activity.
@@ -110,7 +106,7 @@ function actorDehydrator(activity, _context) {
 /**
 * Gets the default activity transformers that are applied to all outgoing
 * activities.
-* @typeParam TContextData The type of the context data.
+* @template TContextData The type of the context data.
 * @returns The default activity transformers.
 * @since 1.4.0
 */
@@ -119,7 +115,7 @@ function getDefaultActivityTransformers() {
 }
 
 //#endregion
-//#region nodeinfo/handler.ts
+//#region src/nodeinfo/handler.ts
 /**
 * Handles a NodeInfo request.  You would not typically call this function
 * directly, but instead use {@link Federation.handle} method.
@@ -157,7 +153,7 @@ function handleNodeInfoJrd(_request, context$1) {
 }
 
 //#endregion
-//#region vocab/constants.ts
+//#region src/vocab/constants.ts
 /**
 * The special public collection for [public addressing].  *Do not mutate this
 * object.*
@@ -169,7 +165,7 @@ function handleNodeInfoJrd(_request, context$1) {
 const PUBLIC_COLLECTION = new URL("https://www.w3.org/ns/activitystreams#Public");
 
 //#endregion
-//#region webfinger/handler.ts
+//#region src/webfinger/handler.ts
 const logger = getLogger([
 	"fedify",
 	"webfinger",
@@ -299,7 +295,7 @@ async function handleWebFingerInternal(request, { context: context$1, host, acto
 }
 
 //#endregion
-//#region federation/negotiation.ts
+//#region src/federation/negotiation.ts
 function compareSpecs(a, b) {
 	return b.q - a.q || (b.s ?? 0) - (a.s ?? 0) || (a.o ?? 0) - (b.o ?? 0) || a.i - b.i || 0;
 }
@@ -357,7 +353,7 @@ function preferredMediaTypes(accept) {
 }
 
 //#endregion
-//#region federation/handler.ts
+//#region src/federation/handler.ts
 function acceptsJsonLd(request) {
 	const accept = request.headers.get("Accept");
 	const types = accept ? preferredMediaTypes(accept) : ["*/*"];
@@ -365,6 +361,13 @@ function acceptsJsonLd(request) {
 	if (types[0] === "text/html" || types[0] === "application/xhtml+xml") return false;
 	return types.includes("application/activity+json") || types.includes("application/ld+json") || types.includes("application/json");
 }
+/**
+* Handles an actor request.
+* @template TContextData The context data to pass to the context.
+* @param request The HTTP request.
+* @param parameters The parameters for handling the actor.
+* @returns A promise that resolves to an HTTP response.
+*/
 async function handleActor(request, { identifier, context: context$1, actorDispatcher, authorizePredicate, onNotFound, onNotAcceptable, onUnauthorized }) {
 	const logger$2 = getLogger([
 		"fedify",
@@ -408,6 +411,13 @@ async function handleActor(request, { identifier, context: context$1, actorDispa
 		Vary: "Accept"
 	} });
 }
+/**
+* Handles an object request.
+* @template TContextData The context data to pass to the context.
+* @param request The HTTP request.
+* @param parameters The parameters for handling the object.
+* @returns A promise that resolves to an HTTP response.
+*/
 async function handleObject(request, { values, context: context$1, objectDispatcher, authorizePredicate, onNotFound, onNotAcceptable, onUnauthorized }) {
 	if (objectDispatcher == null) return await onNotFound(request);
 	const object = await objectDispatcher(context$1, values);
@@ -440,6 +450,16 @@ async function handleObject(request, { values, context: context$1, objectDispatc
 		Vary: "Accept"
 	} });
 }
+/**
+* Handles a collection request.
+* @template TItem The type of items in the collection.
+* @template TContext The type of the context, extending {@link RequestContext}.
+* @template TContextData The context data to pass to the `TContext`.
+* @template TFilter The type of the filter.
+* @param request The HTTP request.
+* @param parameters The parameters for handling the collection.
+* @returns A promise that resolves to an HTTP response.
+*/
 async function handleCollection(request, { name, identifier, uriGetter, filter, filterPredicate, context: context$1, collectionCallbacks, tracerProvider, onUnauthorized, onNotFound, onNotAcceptable }) {
 	const spanName = name.trim().replace(/\s+/g, "_");
 	tracerProvider = tracerProvider ?? trace.getTracerProvider();
@@ -581,6 +601,14 @@ async function handleCollection(request, { name, identifier, uriGetter, filter,
 		Vary: "Accept"
 	} });
 }
+/**
+* Filters collection items based on the provided predicate.
+* @template TItem The type of items to filter.
+* @param items The items to filter.
+* @param collectionName The name of the collection for logging purposes.
+* @param filterPredicate Optional predicate function to filter items.
+* @returns The filtered items as Objects, Links, or URLs.
+*/
 function filterCollectionItems(items, collectionName, filterPredicate) {
 	const result = [];
 	let logged = false;
@@ -604,6 +632,13 @@ function filterCollectionItems(items, collectionName, filterPredicate) {
 	}
 	return result;
 }
+/**
+* Handles an inbox request for ActivityPub activities.
+* @template TContextData The context data to pass to the context.
+* @param request The HTTP request.
+* @param options The parameters for handling the inbox.
+* @returns A promise that resolves to an HTTP response.
+*/
 async function handleInbox(request, options) {
 	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
 	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
@@ -625,6 +660,14 @@ async function handleInbox(request, options) {
 		}
 	});
 }
+/**
+* Internal function for handling inbox requests with detailed processing.
+* @template TContextData The context data to pass to the context.
+* @param request The HTTP request.
+* @param options The parameters for handling the inbox.
+* @param span The OpenTelemetry span for tracing.
+* @returns A promise that resolves to an HTTP response.
+*/
 async function handleInboxInternal(request, { recipient, context: ctx, inboxContextFactory, kv, kvPrefixes, queue, actorDispatcher, inboxListeners, inboxErrorHandler, onNotFound, signatureTimeWindow, skipSignatureVerification, tracerProvider }, span) {
 	const logger$2 = getLogger([
 		"fedify",
@@ -855,6 +898,447 @@ async function handleInboxInternal(request, { recipient, context: ctx, inboxCont
 	});
 }
 /**
+* Handles a custom collection request.
+* @template TItem The type of items in the collection.
+* @template TParams The parameter names of the requested URL.
+* @template TContext The type of the context, extending {@link RequestContext}.
+* @template TContextData The context data to pass to the `TContext`.
+* @param request The HTTP request.
+* @param handleParams Parameters for handling the collection.
+* @returns A promise that resolves to an HTTP response.
+* @since 1.8.0
+*/
+const handleCustomCollection = exceptWrapper(_handleCustomCollection);
+async function _handleCustomCollection(request, { name, values, context: context$1, tracerProvider, collectionCallbacks: callbacks, filterPredicate }) {
+	verifyDefined(callbacks);
+	verifyJsonLdRequest(request);
+	await authIfNeeded(context$1, values, callbacks);
+	const cursor = new URL(request.url).searchParams.get("cursor");
+	return await new CustomCollectionHandler(name, values, context$1, callbacks, tracerProvider, Collection, CollectionPage, filterPredicate).fetchCollection(cursor).toJsonLd().then(respondAsActivity);
+}
+/**
+* Handles an ordered collection request.
+* @template TItem The type of items in the collection.
+* @template TParams The parameter names of the requested URL.
+* @template TContext The type of the context, extending {@link RequestContext}.
+* @template TContextData The context data to pass to the `TContext`.
+* @param request The HTTP request.
+* @param handleParams Parameters for handling the collection.
+* @returns A promise that resolves to an HTTP response.
+* @since 1.8.0
+*/
+const handleOrderedCollection = exceptWrapper(_handleOrderedCollection);
+async function _handleOrderedCollection(request, { name, values, context: context$1, tracerProvider, collectionCallbacks: callbacks, filterPredicate }) {
+	verifyDefined(callbacks);
+	verifyJsonLdRequest(request);
+	await authIfNeeded(context$1, values, callbacks);
+	const cursor = new URL(request.url).searchParams.get("cursor");
+	return await new CustomCollectionHandler(name, values, context$1, callbacks, tracerProvider, OrderedCollection, OrderedCollectionPage, filterPredicate).fetchCollection(cursor).toJsonLd().then(respondAsActivity);
+}
+/**
+* Handling custom collections with support for pagination and filtering.
+* The main flow is on `getCollection`, `dispatch`.
+*
+* @template TItem The type of items in the collection.
+* @template TParams The parameter names of the requested URL.
+* @template TContext The type of the context. {@link Context} or {@link RequestContext}.
+* @template TContextData The context data to pass to the `TContext`.
+* @template TCollection The type of the collection, extending {@link Collection}.
+* @template TCollectionPage The type of the collection page, extending {@link CollectionPage}.
+* @since 1.8.0
+*/
+var CustomCollectionHandler = class {
+	/**
+	* The tracer for telemetry.
+	* @type {Tracer}
+	*/
+	#tracer;
+	/**
+	* The ID of the collection.
+	* @type {URL}
+	*/
+	#id;
+	/**
+	* Store total count of items in the collection.
+	* Use `this.totalItems` to access the total items count.
+	* It is a promise because it may require an asynchronous operation to count items.
+	* @type {Promise<number | null> | undefined}
+	*/
+	#totalItems = void 0;
+	/**
+	* The first cursor for pagination.
+	* It is a promise because it may require an asynchronous operation to get the first cursor.
+	* @type {Promise<string | null> | undefined}
+	*/
+	#dispatcher;
+	#collection = null;
+	/**
+	* Creates a new CustomCollection instance.
+	* @param {string} name The name of the collection.
+	* @param {TParams} values The parameter values for the collection.
+	* @param {TContext} context The request context.
+	* @param {CustomCollectionCallbacks} callbacks The collection callbacks.
+	* @param {TracerProvider} tracerProvider The tracer provider for telemetry.
+	* @param {ConstructorWithTypeId<TCollection>} Collection The Collection constructor.
+	* @param {ConstructorWithTypeId<TCollectionPage>} CollectionPage The CollectionPage constructor.
+	* @param {(item: TItem) => boolean} filterPredicate Optional filter predicate for items.
+	*/
+	constructor(name, values, context$1, callbacks, tracerProvider = trace.getTracerProvider(), Collection$1, CollectionPage$1, filterPredicate) {
+		this.name = name;
+		this.values = values;
+		this.context = context$1;
+		this.callbacks = callbacks;
+		this.tracerProvider = tracerProvider;
+		this.Collection = Collection$1;
+		this.CollectionPage = CollectionPage$1;
+		this.filterPredicate = filterPredicate;
+		this.name = this.name.trim().replace(/\s+/g, "_");
+		this.#tracer = this.tracerProvider.getTracer(deno_default.name, deno_default.version);
+		this.#id = new URL(this.context.url);
+		this.#dispatcher = callbacks.dispatcher.bind(callbacks);
+	}
+	/**
+	* Converts the collection to JSON-LD format.
+	* @returns A promise that resolves to the JSON-LD representation.
+	*/
+	async toJsonLd() {
+		return (await this.collection).toJsonLd(this.context);
+	}
+	/**
+	* Fetches the collection with optional cursor for pagination.
+	* This method is defined for method chaining and to show processing flow properly.
+	* So it is no problem to call `toJsonLd` directly on the instance.
+	* @param cursor The cursor for pagination, or null for the first page.
+	* @returns The CustomCollection instance for method chaining.
+	*/
+	fetchCollection(cursor = null) {
+		this.#collection = this.getCollection(cursor);
+		return this;
+	}
+	/**
+	* Gets the collection or collection page based on the cursor.
+	* @param {string | null} cursor The cursor for pagination, or null for the main collection.
+	* @returns {Promise<TCollection | TCollectionPage>} A promise that resolves to a Collection or CollectionPage.
+	*/
+	async getCollection(cursor = null) {
+		if (cursor !== null) {
+			const props$1 = await this.getPageProps(cursor);
+			return new this.CollectionPage(props$1);
+		}
+		const firstCursor = await this.firstCursor;
+		const props = typeof firstCursor === "string" ? await this.getProps(firstCursor) : await this.getPropsWithoutCursor();
+		return new this.Collection(props);
+	}
+	/**
+	* Gets the properties for a collection page.
+	* Returns the page properties including items, previous and next cursors.
+	* @param {string} cursor The cursor for the page.
+	* @returns A promise that resolves to the page properties.
+	*/
+	async getPageProps(cursor) {
+		const id = this.#id;
+		const pages = await this.getPages({ cursor });
+		const { prevCursor, nextCursor } = pages;
+		const partOf = new URL(id);
+		partOf.searchParams.delete("cursor");
+		return {
+			id,
+			partOf,
+			items: this.filterItems(pages.items),
+			prev: this.appendToUrl(prevCursor),
+			next: this.appendToUrl(nextCursor)
+		};
+	}
+	/**
+	* Gets the properties for a collection with cursors.
+	* Returns the first cursor and last cursor as URL, along with total items count.
+	* @param {string} firstCursor The first cursor for pagination.
+	* @returns A promise that resolves to the collection properties.
+	*/
+	async getProps(firstCursor) {
+		const lastCursor = await this.callbacks.lastCursor?.(this.context, this.values);
+		return {
+			id: this.#id,
+			first: this.appendToUrl(firstCursor),
+			last: this.appendToUrl(lastCursor),
+			totalItems: await this.totalItems
+		};
+	}
+	/**
+	* Gets the properties for a collection of all items and the count.
+	* @returns A promise that resolves to the collection properties.
+	*/
+	async getPropsWithoutCursor() {
+		const totalItems = await this.totalItems;
+		const pages = await this.getPages({ totalItems });
+		return {
+			id: this.#id,
+			totalItems,
+			items: this.filterItems(pages.items)
+		};
+	}
+	/**
+	* Gets a page of items from the collection.
+	* Wraps the dispatcher in a span for telemetry.
+	* @param options Options for getting the page, including cursor and total items.
+	* @returns A promise that resolves to the page items.
+	*/
+	async getPages({ cursor = null, totalItems = null }) {
+		return await this.#tracer.startActiveSpan(`${this.ATTRS.DISPATCH_COLLECTION} ${this.name}`, this.spanOptions(SpanKind.SERVER, cursor), this.spanPages({
+			cursor,
+			totalItems
+		}));
+	}
+	/**
+	* Creates span options for telemetry.
+	* @param {SpanKind} kind The span kind.
+	* @param {string | null} cursor The optional cursor value.
+	* @returns {SpanOptions}The span options.
+	*/
+	spanOptions = (kind, cursor) => ({
+		kind,
+		attributes: {
+			[this.ATTRS.ID]: this.#id.href,
+			[this.ATTRS.TYPE]: this.Collection.typeId.href,
+			...cursor ? { [this.ATTRS.CURSOR]: cursor } : {}
+		}
+	});
+	/**
+	* Creates a function to wrap the dispatcher so tracing can be applied.
+	* @param params Parameters including cursor and total items.
+	* @returns {(span: Span) => Promise<PageItems<TItem>>} A function that handles the span operation.
+	*/
+	spanPages = ({ totalItems = null, cursor = null }) => async (span) => {
+		try {
+			if (totalItems !== null) span.setAttribute(this.ATTRS.TOTAL_ITEMS, totalItems);
+			const page = await this.dispatch(cursor);
+			span.setAttribute(this.ATTRS.ITEMS, page.items.length);
+			return page;
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message
+			});
+			throw e;
+		} finally {
+			span.end();
+		}
+	};
+	/**
+	* Dispatches the collection request to get items.
+	* @param {string | null} cursor The cursor for pagination, or null for the first page.
+	* @returns {Promise<PageItems<TItem>>} A promise that resolves to the page items.
+	*/
+	async dispatch(cursor = null) {
+		return await this.#dispatcher(this.context, this.values, cursor) ?? new ItemsNotFoundError().throw();
+	}
+	/**
+	* Filters the items in the collection.
+	* @param {TItem[]} items The items to filter.
+	* @returns {(Object | Link | URL)[]} The filtered items.
+	*/
+	filterItems(items) {
+		return filterCollectionItems(items, this.name, this.filterPredicate);
+	}
+	/**
+	* Appends a cursor to the URL if it exists.
+	* @param {string | null | undefined} cursor The cursor to append, or null/undefined.
+	* @returns The URL with cursor appended, or null if cursor is null/undefined.
+	*/
+	appendToUrl(cursor) {
+		return appendCursorIfExists(this.context.url, cursor);
+	}
+	/**
+	* Gets the stored collection or collection page.
+	* @returns {Promise<TCollection | TCollectionPage>} A promise that resolves to
+	the collection or collection page.
+	*/
+	get collection() {
+		if (this.#collection === null) this.#collection = this.getCollection();
+		return this.#collection;
+	}
+	/**
+	* Gets the total number of items in the collection.
+	* @returns {Promise<number | null>} A promise that
+	resolves to the total items count, or null if not available.
+	*/
+	get totalItems() {
+		if (this.#totalItems === void 0) this.totalItems = this.callbacks.counter?.(this.context, this.values);
+		return this.#totalItems;
+	}
+	/**
+	* Sets the total number of items in the collection.
+	* @param value The total items count or a promise that resolves to it.
+	*/
+	set totalItems(value) {
+		const toNumber = (value$1) => value$1 == null ? null : Number(value$1);
+		this.#totalItems = value instanceof Promise ? value.then(toNumber) : Promise.resolve(toNumber(value));
+	}
+	/**
+	* Gets the first cursor for pagination.
+	* @returns {Promise<string | null>} A promise that resolves to the first cursor,
+	or null if not available.
+	*/
+	get firstCursor() {
+		const cursor = this.callbacks.firstCursor?.(this.context, this.values);
+		return Promise.resolve(cursor ?? null);
+	}
+	/**
+	* Attribute constants for telemetry spans.
+	*/
+	ATTRS = {
+		DISPATCH_COLLECTION: "activitypub.dispatch_collection",
+		CURSOR: "fedify.collection.cursor",
+		ID: "activitypub.collection.id",
+		ITEMS: "fedify.collection.items",
+		TOTAL_ITEMS: "activitypub.collection.total_items",
+		TYPE: "activitypub.collection.type"
+	};
+};
+/**
+* A wrapper function that catches specific errors and handles them appropriately.
+* @template TParams The type of parameters that extend ErrorHandlers.
+* @param handler The handler function to wrap.
+* @returns A wrapped handler function that catches and handles specific errors.
+* @since 1.8.0
+*/
+function exceptWrapper(handler) {
+	return async (request, handlerParams) => {
+		try {
+			return await handler(request, handlerParams);
+		} catch (error) {
+			const { onNotFound, onNotAcceptable, onUnauthorized } = handlerParams;
+			switch (error?.constructor) {
+				case ItemsNotFoundError: return await onNotFound(request);
+				case NotAcceptableError: return await onNotAcceptable(request);
+				case UnauthorizedError: return await onUnauthorized(request);
+				default: throw error;
+			}
+		}
+	};
+}
+/**
+* Verifies that a value is defined (not undefined).
+* @template T The type of the value, excluding undefined.
+* @param callbacks The value to verify.
+* @throws {ItemsNotFoundError} If the value is undefined.
+* @since 1.8.0
+*/
+const verifyDefined = (callbacks) => {
+	if (callbacks === void 0) throw new ItemsNotFoundError();
+};
+/**
+* Verifies that a request accepts JSON-LD content type.
+* @param request The HTTP request to verify.
+* @throws {NotAcceptableError} If the request doesn't accept JSON-LD.
+* @since 1.8.0
+*/
+const verifyJsonLdRequest = (request) => {
+	if (!acceptsJsonLd(request)) throw new NotAcceptableError();
+};
+/**
+* Performs authorization if needed based on the authorization predicate.
+* @template TContextData The context data type.
+* @param {RequestContext<TContextData>} context The request context.
+* @param {Record<string, string>} values The parameter values.
+* @param options Options containing the authorization predicate.
+* @throws {UnauthorizedError} If authorization fails.
+* @since 1.8.0
+*/
+const authIfNeeded = async (context$1, values, { authorizePredicate: authorize = void 0 }) => {
+	if (authorize === void 0) return;
+	const key = (await context$1.getSignedKey())?.clone({}, warning.key) ?? null;
+	const keyOwner = (await context$1.getSignedKeyOwner())?.clone({}, warning.keyOwner) ?? null;
+	if (!await authorize(context$1, values, key, keyOwner)) throw new UnauthorizedError();
+};
+/** Warning messages for `authIfNeeded`. */
+const warning = {
+	key: { $warning: {
+		category: [
+			"fedify",
+			"federation",
+			"collection"
+		],
+		message: "The third parameter of AuthorizePredicate is deprecated in favor of RequestContext.getSignedKey() method.  The third parameter will be removed in a future release."
+	} },
+	keyOwner: { $warning: {
+		category: [
+			"fedify",
+			"federation",
+			"collection"
+		],
+		message: "The fourth parameter of AuthorizePredicate is deprecated in favor of RequestContext.getSignedKeyOwner() method.  The fourth parameter will be removed in a future release."
+	} }
+};
+/**
+* Appends a cursor parameter to a URL if the cursor exists.
+* @template Cursor The type of the cursor (string, null, or undefined).
+* @param {URL} url The base URL to append the cursor to.
+* @param {string | null | undefined} cursor The cursor value to append.
+* @returns The URL with cursor appended if cursor is a string, null otherwise.
+* @since 1.8.0
+*/
+const appendCursorIfExists = (url, cursor) => {
+	if (cursor === null || cursor === void 0) return null;
+	const copied = new URL(url);
+	copied.searchParams.set("cursor", cursor);
+	return copied;
+};
+/**
+* Creates an HTTP response for ActivityPub data.
+* @param {unknown} data The data to serialize as JSON-LD.
+* @returns {Response} An HTTP response with the data as ActivityPub JSON.
+* @since 1.8.0
+*/
+const respondAsActivity = (data) => new Response(JSON.stringify(data), { headers: {
+	"Content-Type": "application/activity+json",
+	Vary: "Accept"
+} });
+/**
+* Base class for handler errors.
+* @since 1.8.0
+*/
+var HandlerError = class extends Error {
+	constructor(message) {
+		super(message);
+	}
+	/**
+	* Throws this error.
+	* @returns Never returns, always throws.
+	*/
+	throw() {
+		throw this;
+	}
+};
+/**
+* Error thrown when items are not found in a collection.
+* @since 1.8.0
+*/
+var ItemsNotFoundError = class extends HandlerError {
+	constructor() {
+		super("Items not found in the collection.");
+	}
+};
+/**
+* Error thrown when the request is not acceptable (e.g., wrong content type).
+* @since 1.8.0
+*/
+var NotAcceptableError = class extends HandlerError {
+	constructor() {
+		super("The request is not acceptable.");
+	}
+};
+/**
+* Error thrown when access to a collection is unauthorized.
+* @since 1.8.0
+*/
+var UnauthorizedError = class extends HandlerError {
+	constructor() {
+		super("Unauthorized access to the collection.");
+	}
+};
+/**
 * Responds with the given object in JSON-LD format.
 *
 * @param object The object to respond with.
@@ -882,7 +1366,7 @@ async function respondWithObjectIfAcceptable(object, request, options) {
 }
 
 //#endregion
-//#region federation/middleware.ts
+//#region src/federation/middleware.ts
 /**
 * Create a new {@link Federation} instance.
 * @param parameters Parameters for initializing the instance.
@@ -1734,6 +2218,34 @@ var FederationImpl = class extends FederationBuilderImpl {
 				onNotFound,
 				onNotAcceptable
 			});
+			case "collection": {
+				const name = route.name.replace(/^collection:/, "");
+				const callbacks = this.collectionCallbacks[name];
+				return await handleCustomCollection(request, {
+					name,
+					context: context$1,
+					values: route.values,
+					collectionCallbacks: callbacks,
+					tracerProvider: this.tracerProvider,
+					onUnauthorized,
+					onNotFound,
+					onNotAcceptable
+				});
+			}
+			case "orderedCollection": {
+				const name = route.name.replace(/^orderedCollection:/, "");
+				const callbacks = this.collectionCallbacks[name];
+				return await handleOrderedCollection(request, {
+					name,
+					context: context$1,
+					values: route.values,
+					collectionCallbacks: callbacks,
+					tracerProvider: this.tracerProvider,
+					onUnauthorized,
+					onNotFound,
+					onNotAcceptable
+				});
+			}
 			default: {
 				const response = onNotFound(request);
 				return response instanceof Promise ? await response : response;
@@ -1874,6 +2386,11 @@ var ContextImpl = class ContextImpl {
 		if (path == null) throw new RouterError("No featured tags collection path registered.");
 		return new URL(path, this.canonicalOrigin);
 	}
+	getCollectionUri(name, values) {
+		const path = this.federation.getCollectionPath(name, values);
+		if (path === null) throw new RouterError(`No collection dispatcher registered for "${String(name)}".`);
+		return new URL(path, this.canonicalOrigin);
+	}
 	parseUri(uri) {
 		if (uri == null) return null;
 		if (uri.origin !== this.origin && uri.origin !== this.canonicalOrigin) return null;
@@ -1961,6 +2478,20 @@ var ContextImpl = class ContextImpl {
 				return identifier;
 			}
 		};
+		const collectionTypes = ["collection", "orderedCollection"];
+		const collectionRegex = /* @__PURE__ */ new RegExp(`^(${collectionTypes.join("|")}):(.*)$`);
+		const match = route.name.match(collectionRegex);
+		if (match !== null) {
+			const [, type, name] = match;
+			const cls = this.federation.collectionTypeIds[name];
+			return {
+				type,
+				name,
+				class: cls,
+				typeId: cls.typeId,
+				values: route.values
+			};
+		}
 		return null;
 	}
 	async getActorKeyPairs(identifier) {
@@ -2375,7 +2906,7 @@ var RequestContextImpl = class RequestContextImpl extends ContextImpl {
 	#invokedFromActorDispatcher;
 	#invokedFromObjectDispatcher;
 	request;
-	url;
+	url = void 0;
 	constructor(options) {
 		super(options);
 		this.#invokedFromActorDispatcher = options.invokedFromActorDispatcher;
@@ -2680,4 +3211,4 @@ function getRequestId(request) {
 }
 
 //#endregion
-export { ContextImpl, FederationImpl, InboxContextImpl, KvSpecDeterminer, acceptsJsonLd, actorDehydrator, autoIdAssigner, createFederation, handleActor, handleCollection, handleInbox, handleNodeInfo, handleNodeInfoJrd, handleObject, handleWebFinger, respondWithObject, respondWithObjectIfAcceptable };
+export { ContextImpl, FederationImpl, InboxContextImpl, KvSpecDeterminer, acceptsJsonLd, actorDehydrator, autoIdAssigner, createFederation, handleActor, handleCollection, handleCustomCollection, handleInbox, handleNodeInfo, handleNodeInfoJrd, handleObject, handleWebFinger, respondWithObject, respondWithObjectIfAcceptable };