@fedify/fedify 1.8.1-pr.331.1178 → 1.8.1-pr.332.1179

package/dist/{middleware-B5NWowV0.js → middleware-DihQ_X9R.js}

@@ -3,15 +3,15 @@
       import { URLPattern } from "urlpattern-polyfill";
     
 import { getDefaultActivityTransformers } from "./transformers-ghwJuzGY.js";
-import { deno_default, getDocumentLoader, kvCache } from "./docloader-EkABD3kd.js";
-import { Activity, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, getTypeId } from "./actor-3n3a3mn9.js";
-import { lookupWebFinger } from "./lookup-DSIbu5DQ.js";
-import { exportJwk, importJwk, validateCryptoKey } from "./key-CcIJJoyp.js";
-import { doubleKnock, verifyRequest } from "./http-BjAxnWIu.js";
-import { detachSignature, doesActorOwnKey, getKeyOwner, hasSignature, signJsonLd, signObject, verifyJsonLd, verifyObject } from "./proof-CaMDg5Wf.js";
-import { getNodeInfo, nodeInfoToJson } from "./types-BaOxz8EG.js";
-import { getAuthenticatedDocumentLoader } from "./authdocloader-GfBzg16C.js";
-import { lookupObject, traverseCollection } from "./vocab-3WdS2ySQ.js";
+import { deno_default, getDocumentLoader, kvCache } from "./docloader-CHd_rHX1.js";
+import { Activity, Collection, CollectionPage, CryptographicKey, Link, Multikey, Object as Object$1, OrderedCollection, OrderedCollectionPage, getTypeId } from "./actor-BxoA0YAS.js";
+import { lookupWebFinger } from "./lookup-CzGCa7ll.js";
+import { exportJwk, importJwk, validateCryptoKey } from "./key-Bqd_lPUv.js";
+import { doubleKnock, verifyRequest } from "./http-kTQne-Vy.js";
+import { detachSignature, doesActorOwnKey, getKeyOwner, hasSignature, signJsonLd, signObject, verifyJsonLd, verifyObject } from "./proof-DLGV7jUF.js";
+import { getNodeInfo, nodeInfoToJson } from "./types-WOQMaDxr.js";
+import { getAuthenticatedDocumentLoader } from "./authdocloader-BVZHcNUr.js";
+import { lookupObject, traverseCollection } from "./vocab-CjmKyqUK.js";
 import { getLogger, withContext } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 import { encodeHex } from "byte-encodings/hex";
@@ -306,13 +306,17 @@ var FederationBuilderImpl = class {
 	inboxListeners;
 	inboxErrorHandler;
 	sharedInboxKeyDispatcher;
+	collectionTypeIds;
+	collectionCallbacks;
 	constructor() {
 		this.router = new Router$1();
 		this.objectCallbacks = {};
 		this.objectTypeIds = {};
+		this.collectionCallbacks = {};
+		this.collectionTypeIds = {};
 	}
 	async build(options) {
-		const { FederationImpl: FederationImpl$1 } = await import("./middleware-CcZg36yb.js");
+		const { FederationImpl: FederationImpl$1 } = await import("./middleware-ksP_j6kc.js");
 		const f = new FederationImpl$1(options);
 		const trailingSlashInsensitiveValue = f.router.trailingSlashInsensitive;
 		f.router = this.router.clone();
@@ -756,6 +760,41 @@ var FederationBuilderImpl = class {
 		};
 		return setters;
 	}
+	setCollectionDispatcher(name, ...args) {
+		return this.#setCustomCollectionDispatcher(name, "collection", ...args);
+	}
+	setOrderedCollectionDispatcher(name, ...args) {
+		return this.#setCustomCollectionDispatcher(name, "orderedCollection", ...args);
+	}
+	#setCustomCollectionDispatcher(name, collectionType, itemType, path, dispatcher) {
+		const routeName = `${collectionType}:${String(name)}`;
+		if (this.router.has(routeName)) throw new RouterError(`Collection dispatcher for ${String(name)} already set.`);
+		if (this.collectionCallbacks[name] != null) throw new RouterError(`Collection dispatcher for ${String(name)} already set.`);
+		const variables = this.router.add(path, routeName);
+		if (variables.size < 1) throw new RouterError("Path for collection dispatcher must have at least one variable.");
+		const callbacks = { dispatcher };
+		this.collectionCallbacks[name] = callbacks;
+		this.collectionTypeIds[name] = itemType;
+		const setters = {
+			setCounter(counter) {
+				callbacks.counter = counter;
+				return setters;
+			},
+			setFirstCursor(cursor) {
+				callbacks.firstCursor = cursor;
+				return setters;
+			},
+			setLastCursor(cursor) {
+				callbacks.lastCursor = cursor;
+				return setters;
+			},
+			authorize(predicate) {
+				callbacks.authorizePredicate = predicate;
+				return setters;
+			}
+		};
+		return setters;
+	}
 };
 /**
 * Creates a new {@link FederationBuilder} instance.
@@ -914,6 +953,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.
+* @typeParam 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$1 = getLogger([
 		"fedify",
@@ -957,6 +1003,13 @@ async function handleActor(request, { identifier, context: context$1, actorDispa
 		Vary: "Accept"
 	} });
 }
+/**
+* Handles an object request.
+* @typeParam 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);
@@ -989,6 +1042,16 @@ async function handleObject(request, { values, context: context$1, objectDispatc
 		Vary: "Accept"
 	} });
 }
+/**
+* Handles a collection request.
+* @typeParam TItem The type of items in the collection.
+* @typeParam TContext The type of the context, extending {@link RequestContext}.
+* @typeParam TContextData The context data to pass to the `TContext`.
+* @typeParam 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();
@@ -1130,6 +1193,14 @@ async function handleCollection(request, { name, identifier, uriGetter, filter,
 		Vary: "Accept"
 	} });
 }
+/**
+* Filters collection items based on the provided predicate.
+* @typeParam 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;
@@ -1153,6 +1224,13 @@ function filterCollectionItems(items, collectionName, filterPredicate) {
 	}
 	return result;
 }
+/**
+* Handles an inbox request for ActivityPub activities.
+* @typeParam 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);
@@ -1174,6 +1252,14 @@ async function handleInbox(request, options) {
 		}
 	});
 }
+/**
+* Internal function for handling inbox requests with detailed processing.
+* @typeParam 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$1 = getLogger([
 		"fedify",
@@ -1404,6 +1490,447 @@ async function handleInboxInternal(request, { recipient, context: ctx, inboxCont
 	});
 }
 /**
+* Handles a custom collection request.
+* @typeParam TItem The type of items in the collection.
+* @typeParam TParams The parameter names of the requested URL.
+* @typeParam TContext The type of the context, extending {@link RequestContext}.
+* @typeParam 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.
+* @typeParam TItem The type of items in the collection.
+* @typeParam TParams The parameter names of the requested URL.
+* @typeParam TContext The type of the context, extending {@link RequestContext}.
+* @typeParam 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`.
+*
+* @typeParam TItem The type of items in the collection.
+* @typeParam TParams The parameter names of the requested URL.
+* @typeParam TContext The type of the context. {@link Context} or {@link RequestContext}.
+* @typeParam TContextData The context data to pass to the `TContext`.
+* @typeParam TCollection The type of the collection, extending {@link Collection}.
+* @typeParam 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.
+* @typeParam 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).
+* @typeParam 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.
+* @typeParam 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.
+* @typeParam 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("Items not found in the collection.");
+	}
+};
+/**
+* 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.
@@ -2599,6 +3126,34 @@ var FederationImpl = class extends FederationBuilderImpl {
 				onNotFound,
 				onNotAcceptable
 			});
+			case "collection": {
+				const name = route.name.replace(/^collection:/, "");
+				const callbacks = this.collectionCallbacks[name];
+				return await handleOrderedCollection(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;
@@ -2739,6 +3294,18 @@ 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 customCallbacks = this.federation.collectionCallbacks[name];
+		if (customCallbacks != null) {
+			const collectionRouteName = `collection:${String(name)}`;
+			const orderedCollectionRouteName = `orderedCollection:${String(name)}`;
+			let path = this.federation.router.build(collectionRouteName, values);
+			if (path == null) path = this.federation.router.build(orderedCollectionRouteName, values);
+			if (path == null) throw new RouterError(`No collection dispatcher registered for ${String(name)}.`);
+			return new URL(path, this.canonicalOrigin);
+		}
+		throw new RouterError(`No collection dispatcher registered for ${String(name)}.`);
+	}
 	parseUri(uri) {
 		if (uri == null) return null;
 		if (uri.origin !== this.origin && uri.origin !== this.canonicalOrigin) return null;
@@ -2826,6 +3393,19 @@ var ContextImpl = class ContextImpl {
 				return identifier;
 			}
 		};
+		const collectionRegex = /^(orderedC|c)ollection:(.*)$/;
+		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) {