@fedify/fedify 2.3.0-dev.1212 → 2.3.0-dev.1213

package/dist/{middleware-CRORNnSU.cjs → middleware-DlqW4IRW.cjs}

@@ -2,10 +2,10 @@ const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 const require_chunk = require("./chunk-DDcVe30Y.cjs");
 const require_transformers = require("./transformers-NeAONrAq.cjs");
-const require_http = require("./http-Czeyq7if.cjs");
-const require_proof = require("./proof-frzCtYji.cjs");
+const require_http = require("./http-B1zlPuh3.cjs");
+const require_proof = require("./proof-BKpJ_p_d.cjs");
 const require_types = require("./types-KC4QAoxe.cjs");
-const require_kv_cache = require("./kv-cache-qRBN2G2Z.cjs");
+const require_kv_cache = require("./kv-cache-CPIfTWt5.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_uri_template = require("@fedify/uri-template");
 let _fedify_vocab = require("@fedify/vocab");
@@ -17,6 +17,7 @@ let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conve
 let _fedify_vocab_runtime_jsonld = require("@fedify/vocab-runtime/jsonld");
 _fedify_vocab_runtime_jsonld = require_chunk.__toESM(_fedify_vocab_runtime_jsonld, 1);
 let _fedify_webfinger = require("@fedify/webfinger");
+let _opentelemetry_sdk_metrics = require("@opentelemetry/sdk-metrics");
 let node_url = require("node:url");
 //#region src/federation/activity-listener.ts
 var ActivityListenerSet = class {
@@ -118,6 +119,13 @@ var FederationBuilderImpl = class {
 		this.collectionCallbacks = {};
 		this.collectionTypeIds = {};
 	}
+	/**
+	* Builds the federation object.
+	* @param options Parameters for initializing the federation object.
+	* @returns The federation object.
+	* @throws {TypeError} If benchmark mode and `meterProvider` are both
+	* specified.
+	*/
 	async build(options) {
 		const { FederationImpl } = await Promise.resolve().then(() => middleware_exports);
 		const f = new FederationImpl(options);
@@ -3073,36 +3081,6 @@ function handleNodeInfoJrd(_request, context) {
 	return Promise.resolve(response);
 }
 //#endregion
-//#region src/federation/retry.ts
-/**
-* Creates an exponential backoff retry policy.  The delay between retries
-* starts at the `initialDelay` and is multiplied by the `factor` for each
-* subsequent retry, up to the `maxDelay`.  The policy will give up after
-* `maxAttempts` attempts.  The actual delay is randomized to avoid
-* synchronization (jitter).
-* @param options The options for the policy.
-* @returns The retry policy.
-* @since 0.12.0
-*/
-function createExponentialBackoffPolicy(options = {}) {
-	const initialDelay = Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
-	const maxDelay = Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
-	const maxAttempts = options.maxAttempts ?? 10;
-	const factor = options.factor ?? 2;
-	const jitter = options.jitter ?? true;
-	return ({ attempts }) => {
-		if (attempts >= maxAttempts) return null;
-		let milliseconds = initialDelay.total("millisecond");
-		milliseconds *= factor ** attempts;
-		if (jitter) {
-			milliseconds *= 1 + Math.random();
-			milliseconds = Math.round(milliseconds);
-		}
-		const delay = Temporal.Duration.from({ milliseconds });
-		return Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
-	};
-}
-//#endregion
 //#region src/federation/send.ts
 /**
 * Extracts the inbox URLs from recipients.
@@ -3332,6 +3310,231 @@ var SendActivityError = class extends Error {
 	}
 };
 //#endregion
+//#region src/federation/bench.ts
+/**
+* Metric reader owned by `benchmarkMode`.
+* @since 2.3.0
+*/
+var BenchmarkMetricReader = class extends _opentelemetry_sdk_metrics.MetricReader {
+	onShutdown() {
+		return Promise.resolve();
+	}
+	onForceFlush() {
+		return Promise.resolve();
+	}
+};
+/**
+* Creates the in-process OpenTelemetry meter provider used by benchmark mode.
+* @returns The meter provider and the metric reader attached to it.
+* @since 2.3.0
+*/
+function createBenchmarkMeterProvider() {
+	const reader = new BenchmarkMetricReader();
+	return {
+		meterProvider: new _opentelemetry_sdk_metrics.MeterProvider({ readers: [reader] }),
+		reader
+	};
+}
+/**
+* Collects and serializes benchmark-mode metrics from a benchmark reader.
+* @param reader The benchmark metric reader to collect from.
+* @returns A server metric snapshot with any collection errors stringified.
+* @since 2.3.0
+*/
+async function collectBenchmarkMetrics(reader) {
+	const result = await reader.collect();
+	return {
+		version: 1,
+		source: "server",
+		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		scopeMetrics: serializeScopeMetrics(result.resourceMetrics),
+		errors: result.errors.map((error) => String(error))
+	};
+}
+/**
+* Handles `GET /.well-known/fedify/bench/stats`.
+* @param request The HTTP request to handle.
+* @param reader The benchmark metric reader to collect from.
+* @returns A JSON metric snapshot response, or `405 Method Not Allowed`.
+* @since 2.3.0
+*/
+async function handleBenchmarkStats(request, reader) {
+	if (request.method !== "GET") return new Response("Method not allowed", {
+		status: 405,
+		headers: { "Allow": "GET" }
+	});
+	return jsonResponse(await collectBenchmarkMetrics(reader));
+}
+/**
+* Handles `POST /.well-known/fedify/bench/trigger`.
+*
+* The handler validates a benchmark trigger request, checks recipients against
+* server-controlled trigger options, and calls `Context.sendActivity()` to use
+* the target's normal outbox path.
+* @param request The HTTP request to handle.
+* @param context The Fedify context used to resolve actors and send activity.
+* @param options Server-controlled benchmark trigger delivery options.
+* @returns A JSON response describing the sent activity, or a validation error.
+* @since 2.3.0
+*/
+async function handleBenchmarkTrigger(request, context, options = {}) {
+	if (request.method !== "POST") return new Response("Method not allowed", {
+		status: 405,
+		headers: { "Allow": "POST" }
+	});
+	let json;
+	try {
+		json = await request.json();
+	} catch {
+		return jsonResponse({ error: "Invalid JSON request body." }, 400);
+	}
+	try {
+		const body = asRecord(json, "request body");
+		const sender = parseSender(body.sender);
+		const recipients = await parseRecipients(body.recipients, context);
+		const activity = await parseActivity(body.activity, context);
+		if (activity.id == null) throw new BenchmarkTriggerError("activity must have an id.");
+		const activityId = activity.id.href;
+		const inboxes = extractInboxes({ recipients });
+		const inboxUrls = Object.keys(inboxes);
+		if (inboxUrls.length < 1) throw new BenchmarkTriggerError("No valid recipient inboxes found. The recipients list must not be empty.");
+		const unsafeInboxes = options.allowUnsafeRecipients ? [] : inboxUrls.filter((inbox) => !options.sinks?.has(inbox));
+		if (unsafeInboxes.length > 0) return jsonResponse({
+			error: "unsafe_recipient",
+			unsafeInboxes
+		}, 403);
+		await context.sendActivity(sender, recipients, activity);
+		return jsonResponse({
+			version: 1,
+			activityId,
+			queueCorrelationId: activityId,
+			recipientCount: recipients.length,
+			inboxCount: inboxUrls.length
+		}, 202);
+	} catch (error) {
+		if (error instanceof BenchmarkTriggerError) return jsonResponse({ error: error.message }, error.status);
+		throw error;
+	}
+}
+var BenchmarkTriggerError = class extends Error {
+	status;
+	constructor(message, status = 400) {
+		super(message);
+		this.status = status;
+	}
+};
+function parseSender(value) {
+	const sender = asRecord(value, "sender");
+	if (typeof sender.identifier === "string") return { identifier: sender.identifier };
+	if (typeof sender.username === "string") return { username: sender.username };
+	throw new BenchmarkTriggerError("sender must be { identifier } or { username }.");
+}
+async function parseRecipients(value, context) {
+	if (!Array.isArray(value)) throw new BenchmarkTriggerError("recipients must be an array.");
+	return await Promise.all(value.map(async (item) => {
+		let object;
+		try {
+			object = await _fedify_vocab.Object.fromJsonLd(item, {
+				documentLoader: context.documentLoader,
+				contextLoader: context.contextLoader
+			});
+		} catch (error) {
+			throw new BenchmarkTriggerError(`Invalid ActivityPub recipient: ${error}`);
+		}
+		if (!isRecipient(object)) throw new BenchmarkTriggerError("each recipient must be an ActivityPub actor.");
+		const recipient = object;
+		if (recipient.id == null || recipient.inboxId == null) throw new BenchmarkTriggerError("each recipient must have id and inbox properties.");
+		return recipient;
+	}));
+}
+function isRecipient(value) {
+	return value != null && typeof value === "object" && "id" in value && "inboxId" in value;
+}
+async function parseActivity(value, context) {
+	try {
+		return await _fedify_vocab.Activity.fromJsonLd(value, {
+			documentLoader: context.documentLoader,
+			contextLoader: context.contextLoader
+		});
+	} catch (error) {
+		throw new BenchmarkTriggerError(`Invalid ActivityPub activity: ${error}`);
+	}
+}
+function asRecord(value, name) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new BenchmarkTriggerError(`${name} must be an object.`);
+	return value;
+}
+function jsonResponse(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function serializeScopeMetrics(resourceMetrics) {
+	return resourceMetrics.scopeMetrics.map(serializeScope);
+}
+function serializeScope(scopeMetrics) {
+	return {
+		scope: {
+			name: scopeMetrics.scope.name,
+			version: scopeMetrics.scope.version
+		},
+		metrics: scopeMetrics.metrics.map(serializeMetric)
+	};
+}
+function serializeMetric(metric) {
+	return {
+		name: metric.descriptor.name,
+		description: metric.descriptor.description,
+		unit: metric.descriptor.unit,
+		dataPointType: serializeDataPointType(metric.dataPointType),
+		dataPoints: metric.dataPoints.map((point) => ({
+			attributes: { ...point.attributes },
+			startTime: point.startTime,
+			endTime: point.endTime,
+			value: point.value
+		}))
+	};
+}
+function serializeDataPointType(dataPointType) {
+	switch (dataPointType) {
+		case _opentelemetry_sdk_metrics.DataPointType.HISTOGRAM: return "histogram";
+		case _opentelemetry_sdk_metrics.DataPointType.EXPONENTIAL_HISTOGRAM: return "exponential_histogram";
+		case _opentelemetry_sdk_metrics.DataPointType.GAUGE: return "gauge";
+		case _opentelemetry_sdk_metrics.DataPointType.SUM: return "sum";
+	}
+}
+//#endregion
+//#region src/federation/retry.ts
+/**
+* Creates an exponential backoff retry policy.  The delay between retries
+* starts at the `initialDelay` and is multiplied by the `factor` for each
+* subsequent retry, up to the `maxDelay`.  The policy will give up after
+* `maxAttempts` attempts.  The actual delay is randomized to avoid
+* synchronization (jitter).
+* @param options The options for the policy.
+* @returns The retry policy.
+* @since 0.12.0
+*/
+function createExponentialBackoffPolicy(options = {}) {
+	const initialDelay = Temporal.Duration.from(options.initialDelay ?? { seconds: 1 });
+	const maxDelay = Temporal.Duration.from(options.maxDelay ?? { hours: 12 });
+	const maxAttempts = options.maxAttempts ?? 10;
+	const factor = options.factor ?? 2;
+	const jitter = options.jitter ?? true;
+	return ({ attempts }) => {
+		if (attempts >= maxAttempts) return null;
+		let milliseconds = initialDelay.total("millisecond");
+		milliseconds *= factor ** attempts;
+		if (jitter) {
+			milliseconds *= 1 + Math.random();
+			milliseconds = Math.round(milliseconds);
+		}
+		const delay = Temporal.Duration.from({ milliseconds });
+		return Temporal.Duration.compare(delay, maxDelay) > 0 ? maxDelay : delay;
+	};
+}
+//#endregion
 //#region src/federation/webfinger.ts
 const logger = (0, _logtape_logtape.getLogger)([
 	"fedify",
@@ -3528,6 +3731,7 @@ var middleware_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	createFederation: () => createFederation
 });
 const circuitBreakerCasWarningKvStores = /* @__PURE__ */ new WeakSet();
+let nextQueueDepthGaugeSourceId = 0;
 const retryAfterHttpDate = /* @__PURE__ */ new RegExp("^(?:(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \\d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \\d{4} \\d{2}:\\d{2}:\\d{2} GMT|(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \\d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\\d{2} \\d{2}:\\d{2}:\\d{2} GMT|(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (?: \\d|\\d{2}) \\d{2}:\\d{2}:\\d{2} \\d{4})$");
 function parseRetryAfter(headers, now = Temporal.Now.instant()) {
 	const value = headers.get("Retry-After");
@@ -3556,6 +3760,54 @@ function parseRetryAfterDuration(durationLike) {
 function clampNegativeDelay(delay) {
 	return delay.sign < 0 ? Temporal.Duration.from({ seconds: 0 }) : delay;
 }
+function getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow) {
+	const relaxations = [];
+	if (allowPrivateAddress) relaxations.push({
+		protection: "private_address_checks",
+		effect: "disabled",
+		effectiveValue: true
+	});
+	if (signatureTimeWindow === false) relaxations.push({
+		protection: "http_signature_time_window",
+		effect: "disabled",
+		effectiveValue: false,
+		secureDefaultSeconds: 3600
+	});
+	else try {
+		const seconds = Temporal.Duration.from(signatureTimeWindow).total({ unit: "seconds" });
+		if (seconds !== 3600) relaxations.push({
+			protection: "http_signature_time_window",
+			effect: "changed",
+			effectiveSeconds: seconds,
+			secureDefaultSeconds: 3600
+		});
+	} catch {}
+	return relaxations;
+}
+function formatBenchmarkRelaxations(relaxations) {
+	if (relaxations.length < 1) return "no benchmark-only protections relaxed";
+	return relaxations.map((relaxation) => {
+		switch (relaxation.protection) {
+			case "private_address_checks": return "private address checks disabled (allowPrivateAddress=true)";
+			case "http_signature_time_window":
+				if (relaxation.effect === "disabled") return `HTTP Signature time window disabled (signatureTimeWindow=false)`;
+				return `HTTP Signature time window set to ${relaxation.effectiveSeconds}s (secure default: ${relaxation.secureDefaultSeconds}s)`;
+		}
+	}).join("; ");
+}
+function getBenchmarkTriggerOptions(benchmarkOptions) {
+	const sinks = benchmarkOptions.triggerSinks?.map((sink) => {
+		try {
+			return new URL(sink).href;
+		} catch {
+			throw new TypeError("benchmarkMode.triggerSinks must contain only URLs.");
+		}
+	});
+	return {
+		sinks: sinks == null ? void 0 : new Set(sinks),
+		allowUnsafeRecipients: benchmarkOptions.allowUnsafeTriggerRecipients === true
+	};
+}
 function maxDelay(first, second) {
 	return Temporal.Duration.compare(first, second) >= 0 ? first : second;
 }
@@ -3592,8 +3844,10 @@ function isPermanentInboxParseError(error) {
 }
 /**
 * Create a new {@link Federation} instance.
-* @param parameters Parameters for initializing the instance.
+* @param options Parameters for initializing the instance.
 * @returns A new {@link Federation} instance.
+* @throws {TypeError} If benchmark mode and `meterProvider` are both
+* specified.
 * @since 0.10.0
 */
 function createFederation(options) {
@@ -3627,8 +3881,31 @@ var FederationImpl = class extends FederationBuilderImpl {
 	_meterProvider;
 	firstKnock;
 	inboxChallengePolicy;
+	benchmarkMode;
+	benchmarkMetricReader;
+	benchmarkTriggerOptions;
+	#queueDepthGaugeSourceId = `fedify-${(++nextQueueDepthGaugeSourceId).toString(36)}`;
+	#queueDepthGaugeEntries = [];
+	#queueDepthGaugeMeterProvider;
 	constructor(options) {
 		super();
+		const benchmarkMode = options.benchmarkMode != null && options.benchmarkMode !== false;
+		const benchmarkOptions = typeof options.benchmarkMode === "object" ? options.benchmarkMode : {};
+		const hasCustomLoaderFactory = options.documentLoaderFactory != null || options.contextLoaderFactory != null;
+		const allowPrivateAddress = options.allowPrivateAddress ?? (benchmarkMode && !hasCustomLoaderFactory ? true : false);
+		const signatureTimeWindow = options.signatureTimeWindow ?? (benchmarkMode ? false : { hours: 1 });
+		if (benchmarkMode && options.meterProvider != null) throw new TypeError("benchmarkMode requires Fedify to own the meterProvider; OpenTelemetry metric readers cannot be added after a MeterProvider is constructed.");
+		if (benchmarkMode) {
+			const relaxations = getBenchmarkRelaxations(allowPrivateAddress, signatureTimeWindow);
+			const relaxationSummary = formatBenchmarkRelaxations(relaxations);
+			(0, _logtape_logtape.getLogger)([
+				"fedify",
+				"federation",
+				"benchmark"
+			]).warn(`Fedify benchmarkMode is enabled; ${relaxationSummary}. Benchmark endpoints are active and must not be used in production.`, { relaxations });
+		}
+		this.benchmarkMode = benchmarkMode;
+		this.benchmarkTriggerOptions = benchmarkMode ? getBenchmarkTriggerOptions(benchmarkOptions) : {};
 		this.kv = options.kv;
 		this.kvPrefixes = {
 			activityIdempotence: ["_fedify", "activityIdempotence"],
@@ -3696,13 +3973,13 @@ var FederationImpl = class extends FederationBuilderImpl {
 		}
 		this.router.trailingSlashInsensitive = options.trailingSlashInsensitive ?? false;
 		this._initializeRouter();
-		if (options.allowPrivateAddress || options.userAgent != null) {
+		if (options.allowPrivateAddress === true || options.userAgent != null) {
 			if (options.documentLoaderFactory != null) throw new TypeError("Cannot set documentLoaderFactory with allowPrivateAddress or userAgent options.");
 			if (options.contextLoaderFactory != null) throw new TypeError("Cannot set contextLoaderFactory with allowPrivateAddress or userAgent options.");
 			if (options.authenticatedDocumentLoaderFactory != null) throw new TypeError("Cannot set authenticatedDocumentLoaderFactory with allowPrivateAddress or userAgent options.");
 		}
-		const { allowPrivateAddress, userAgent } = options;
-		this.allowPrivateAddress = allowPrivateAddress ?? false;
+		const { userAgent } = options;
+		this.allowPrivateAddress = allowPrivateAddress;
 		const userDocumentLoaderFactory = options.documentLoaderFactory;
 		const userContextLoaderFactory = options.contextLoaderFactory;
 		const userAuthFactory = options.authenticatedDocumentLoaderFactory;
@@ -3750,25 +4027,55 @@ var FederationImpl = class extends FederationBuilderImpl {
 		this.userAgent = userAgent;
 		this.onOutboxError = options.onOutboxError;
 		this.permanentFailureStatusCodes = options.permanentFailureStatusCodes ?? [404, 410];
-		this.signatureTimeWindow = options.signatureTimeWindow ?? { hours: 1 };
+		this.signatureTimeWindow = signatureTimeWindow;
 		this.skipSignatureVerification = options.skipSignatureVerification ?? false;
 		this.inboxChallengePolicy = options.inboxChallengePolicy;
 		this.outboxRetryPolicy = options.outboxRetryPolicy ?? createExponentialBackoffPolicy();
 		this.inboxRetryPolicy = options.inboxRetryPolicy ?? createExponentialBackoffPolicy();
 		this.activityTransformers = options.activityTransformers ?? require_transformers.getDefaultActivityTransformers();
 		this._tracerProvider = options.tracerProvider;
-		this._meterProvider = options.meterProvider;
+		if (benchmarkMode) {
+			const benchmarkMetrics = createBenchmarkMeterProvider();
+			this._meterProvider = benchmarkMetrics.meterProvider;
+			this.benchmarkMetricReader = benchmarkMetrics.reader;
+		} else this._meterProvider = options.meterProvider;
+		this.#queueDepthGaugeEntries = [
+			{
+				role: "inbox",
+				queue: this.inboxQueue
+			},
+			{
+				role: "outbox",
+				queue: this.outboxQueue
+			},
+			{
+				role: "fanout",
+				queue: this.fanoutQueue
+			}
+		];
+		this.#registerQueueDepthGauge(this._meterProvider ?? _opentelemetry_api.metrics.getMeterProvider());
 		this.firstKnock = options.firstKnock;
 	}
 	get tracerProvider() {
 		return this._tracerProvider ?? _opentelemetry_api.trace.getTracerProvider();
 	}
 	get meterProvider() {
-		return this._meterProvider ?? _opentelemetry_api.metrics.getMeterProvider();
+		const meterProvider = this._meterProvider ?? _opentelemetry_api.metrics.getMeterProvider();
+		this.#registerQueueDepthGauge(meterProvider);
+		return meterProvider;
+	}
+	#registerQueueDepthGauge(meterProvider) {
+		if (meterProvider === this.#queueDepthGaugeMeterProvider) return;
+		require_http.registerQueueDepthGauge(meterProvider, this.#queueDepthGaugeEntries, { sourceId: this.#queueDepthGaugeSourceId });
+		this.#queueDepthGaugeMeterProvider = meterProvider;
 	}
 	_initializeRouter() {
 		this.router.add("/.well-known/webfinger", "webfinger");
 		this.router.add("/.well-known/nodeinfo", "nodeInfoJrd");
+		if (this.benchmarkMode) {
+			this.router.add("/.well-known/fedify/bench/stats", "benchmarkStats");
+			this.router.add("/.well-known/fedify/bench/trigger", "benchmarkTrigger");
+		}
 	}
 	_getTracer() {
 		return this.tracerProvider.getTracer(require_http.name, require_http.version);
@@ -4780,6 +5087,8 @@ var FederationImpl = class extends FederationBuilderImpl {
 				context,
 				nodeInfoDispatcher: this.nodeInfoDispatcher
 			});
+			case "benchmarkStats": return await handleBenchmarkStats(request, this.benchmarkMetricReader);
+			case "benchmarkTrigger": return await handleBenchmarkTrigger(request, context, this.benchmarkTriggerOptions);
 		}
 		if (request.method !== "POST" && !acceptsJsonLd(request)) {
 			metricState.endpoint = "not_acceptable";
@@ -5019,6 +5328,8 @@ function getEndpointCategory(routeName) {
 		case "liked": return "liked";
 		case "featured": return "featured";
 		case "featuredTags": return "featured_tags";
+		case "benchmarkStats":
+		case "benchmarkTrigger": return "benchmark";
 		default: return "not_found";
 	}
 }

package/dist/{mod-YLnSsEHY.d.cts → mod-C0F6kvgS.d.cts}

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { G as ActorHandleMapper, U as ActorAliasMapper, W as ActorDispatcher, ft as WebFingerLinksDispatcher, l as RequestContext } from "./context-DMHK7jqX.cjs";
+import { G as ActorDispatcher, K as ActorHandleMapper, W as ActorAliasMapper, l as RequestContext, pt as WebFingerLinksDispatcher } from "./context-BBVLF7lx.cjs";
 import { MeterProvider, Span, Tracer } from "@opentelemetry/api";
 import { RouterError, RouterOptions, RouterRouteResult } from "@fedify/uri-template";
 

package/dist/{mod-CfOFqS0w.d.ts → mod-vPYVoa5n.d.ts}

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { G as ActorHandleMapper, U as ActorAliasMapper, W as ActorDispatcher, ft as WebFingerLinksDispatcher, l as RequestContext } from "./context-K9cg8oGx.js";
+import { G as ActorDispatcher, K as ActorHandleMapper, W as ActorAliasMapper, l as RequestContext, pt as WebFingerLinksDispatcher } from "./context-BU6jSQdo.js";
 import { RouterError, RouterOptions, RouterRouteResult } from "@fedify/uri-template";
 import { MeterProvider, Span, Tracer } from "@opentelemetry/api";
 

package/dist/mod.cjs

@@ -4,11 +4,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("./chunk-DDcVe30Y.cjs");
 const require_transformers = require("./transformers-NeAONrAq.cjs");
 require("./compat/mod.cjs");
-const require_http = require("./http-Czeyq7if.cjs");
-const require_middleware = require("./middleware-CRORNnSU.cjs");
-const require_proof = require("./proof-frzCtYji.cjs");
+const require_http = require("./http-B1zlPuh3.cjs");
+const require_middleware = require("./middleware-DlqW4IRW.cjs");
+const require_proof = require("./proof-BKpJ_p_d.cjs");
 const require_types = require("./types-KC4QAoxe.cjs");
-const require_kv_cache = require("./kv-cache-qRBN2G2Z.cjs");
+const require_kv_cache = require("./kv-cache-CPIfTWt5.cjs");
 const require_federation_mod = require("./federation/mod.cjs");
 require("./nodeinfo/mod.cjs");
 require("./runtime/mod.cjs");

package/dist/mod.d.cts

@@ -2,18 +2,18 @@
 import { a as InboundService, c as OutboundService, d as Software, f as Usage, i as parseNodeInfo, l as Protocol, n as ParseNodeInfoOptions, o as JsonValue, p as nodeInfoToJson, r as getNodeInfo, s as NodeInfo, t as GetNodeInfoOptions, u as Services } from "./client-CAM_bQXx.cjs";
 import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "./http-VyDTd4G3.cjs";
 import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "./owner-DEvZuyOE.cjs";
-import { $ as CustomCollectionDispatcher, A as FederationKvPrefixes, At as ActivityTransformer, B as RespondWithObjectOptions, C as IdempotencyKeyCallback, Ct as CircuitBreakerKvState, D as ObjectCallbackSetters, Dt as NormalizedCircuitBreakerOptions, E as InboxListenerSetters, Et as CircuitBreakerStateChange, F as RetryContext, G as ActorHandleMapper, H as respondWithObjectIfAcceptable, I as RetryPolicy, J as CollectionCounter, K as ActorKeyPairsDispatcher, L as createExponentialBackoffPolicy, M as FederationQueueOptions, N as createFederation, O as OutboxListenerSetters, Ot as normalizeCircuitBreakerOptions, P as CreateExponentialBackoffPolicyOptions, Q as CustomCollectionCursor, R as Message, S as FederationStartQueueOptions, St as CircuitBreakerFailurePolicy, T as InboxChallengePolicy, Tt as CircuitBreakerState, U as ActorAliasMapper, V as respondWithObject, W as ActorDispatcher, X as CollectionDispatcher, Y as CollectionCursor, Z as CustomCollectionCounter, _ as Federatable, _t as digest, a as GetSignedKeyOptions, at as OutboxErrorHandler, b as FederationFetchOptions, bt as CircuitBreakerBeforeSendDecision, c as ParseUriResult, ct as OutboxPermanentFailureHandler, d as SendActivityOptions, dt as UnverifiedActivityReason, et as InboxErrorHandler, f as SendActivityOptionsForCollection, ft as WebFingerLinksDispatcher, g as CustomCollectionCallbackSetters, gt as buildCollectionSynchronizationHeader, h as ConstructorWithTypeId, ht as PageItems, i as GetActorOptions, it as ObjectDispatcher, j as FederationOrigin, k as Rfc6570Expression, kt as parseCircuitBreakerKvState, l as RequestContext, lt as SharedInboxKeyDispatcher, m as CollectionCallbackSetters, mt as SenderKeyPair, n as Context, nt as NodeInfoDispatcher, o as InboxContext, ot as OutboxListener, p as ActorCallbackSetters, pt as SendActivityError, q as AuthorizePredicate, r as ForwardActivityOptions, rt as ObjectAuthorizePredicate, s as OutboxContext, st as OutboxListenerErrorHandler, t as ActorKeyPair, tt as InboxListener, u as RouteActivityOptions, ut as UnverifiedActivityHandler, v as Federation, vt as CircuitBreaker, w as IdempotencyStrategy, wt as CircuitBreakerOptions, x as FederationOptions, xt as CircuitBreakerCreateOptions, y as FederationBuilder, yt as CircuitBreakerActivityDrop, z as createFederationBuilder } from "./context-DMHK7jqX.cjs";
+import { $ as CustomCollectionCursor, A as Rfc6570Expression, At as parseCircuitBreakerKvState, B as createFederationBuilder, C as FederationStartQueueOptions, Ct as CircuitBreakerFailurePolicy, D as InboxListenerSetters, Dt as CircuitBreakerStateChange, E as InboxChallengePolicy, Et as CircuitBreakerState, F as CreateExponentialBackoffPolicyOptions, G as ActorDispatcher, H as respondWithObject, I as RetryContext, J as AuthorizePredicate, K as ActorHandleMapper, L as RetryPolicy, M as FederationOrigin, N as FederationQueueOptions, O as ObjectCallbackSetters, Ot as NormalizedCircuitBreakerOptions, P as createFederation, Q as CustomCollectionCounter, R as createExponentialBackoffPolicy, S as FederationOptions, St as CircuitBreakerCreateOptions, T as IdempotencyStrategy, Tt as CircuitBreakerOptions, U as respondWithObjectIfAcceptable, V as RespondWithObjectOptions, W as ActorAliasMapper, X as CollectionCursor, Y as CollectionCounter, Z as CollectionDispatcher, _ as Federatable, _t as buildCollectionSynchronizationHeader, a as GetSignedKeyOptions, at as ObjectDispatcher, b as FederationBuilder, bt as CircuitBreakerActivityDrop, c as ParseUriResult, ct as OutboxListenerErrorHandler, d as SendActivityOptions, dt as UnverifiedActivityHandler, et as CustomCollectionDispatcher, f as SendActivityOptionsForCollection, ft as UnverifiedActivityReason, g as CustomCollectionCallbackSetters, gt as PageItems, h as ConstructorWithTypeId, ht as SenderKeyPair, i as GetActorOptions, it as ObjectAuthorizePredicate, j as FederationKvPrefixes, jt as ActivityTransformer, k as OutboxListenerSetters, kt as normalizeCircuitBreakerOptions, l as RequestContext, lt as OutboxPermanentFailureHandler, m as CollectionCallbackSetters, mt as SendActivityError, n as Context, nt as InboxListener, o as InboxContext, ot as OutboxErrorHandler, p as ActorCallbackSetters, pt as WebFingerLinksDispatcher, q as ActorKeyPairsDispatcher, r as ForwardActivityOptions, rt as NodeInfoDispatcher, s as OutboxContext, st as OutboxListener, t as ActorKeyPair, tt as InboxErrorHandler, u as RouteActivityOptions, ut as SharedInboxKeyDispatcher, v as Federation, vt as digest, w as IdempotencyKeyCallback, wt as CircuitBreakerKvState, x as FederationFetchOptions, xt as CircuitBreakerBeforeSendDecision, y as FederationBenchmarkOptions, yt as CircuitBreaker, z as Message } from "./context-BBVLF7lx.cjs";
 import { a as MemoryKvStore, i as KvStoreSetOptions, n as KvStore, r as KvStoreListEntry, t as KvKey } from "./kv-gJ8LYbxX.cjs";
 import { a as MessageQueueEnqueueOptions, i as MessageQueueDepth, n as InProcessMessageQueueOptions, o as MessageQueueListenOptions, r as MessageQueue, s as ParallelMessageQueue, t as InProcessMessageQueue } from "./mq-D8uSFzxe.cjs";
 import { actorDehydrator, autoIdAssigner, getDefaultActivityTransformers } from "./compat/mod.cjs";
-import { a as RouterOptions, i as RouterError, n as handleWebFinger, o as RouterRouteResult, r as Router, t as WebFingerHandlerParameters } from "./mod-YLnSsEHY.cjs";
+import { a as RouterOptions, i as RouterError, n as handleWebFinger, o as RouterRouteResult, r as Router, t as WebFingerHandlerParameters } from "./mod-C0F6kvgS.cjs";
 import { _ as hasSignatureLike, a as createProof, b as verifySignature, c as verifyObject, d as SignJsonLdOptions, f as VerifyJsonLdOptions, g as detachSignature, h as createSignature, i as VerifyProofOptions, l as verifyProof, m as attachSignature, n as SignObjectOptions, o as hasProofLike, p as VerifySignatureOptions, r as VerifyObjectOptions, s as signObject, t as CreateProofOptions, u as CreateSignatureOptions, v as signJsonLd, y as verifyJsonLd } from "./mod-B0hW12_O.cjs";
 import { n as getAuthenticatedDocumentLoader, t as kvCache } from "./mod-yvIXFAEi.cjs";
 export * from "@fedify/vocab-runtime";
 
 //#region src/mod.d.ts
 declare namespace mod_d_exports {
-  export { AcceptSignatureMember, AcceptSignatureParameters, ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CircuitBreaker, CircuitBreakerActivityDrop, CircuitBreakerBeforeSendDecision, CircuitBreakerCreateOptions, CircuitBreakerFailurePolicy, CircuitBreakerKvState, CircuitBreakerOptions, CircuitBreakerState, CircuitBreakerStateChange, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateProofOptions, CreateSignatureOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, DoesActorOwnKeyOptions, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, ForwardActivityOptions, FulfillAcceptSignatureResult, GetActorOptions, GetKeyOwnerOptions, GetNodeInfoOptions, GetSignedKeyOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboundService, InboxChallengePolicy, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, JsonValue, KeyCache, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, MemoryKvStore, Message, MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfo, NodeInfoDispatcher, NormalizedCircuitBreakerOptions, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboundService, OutboxContext, OutboxErrorHandler, OutboxListener, OutboxListenerErrorHandler, OutboxListenerSetters, OutboxPermanentFailureHandler, PageItems, ParallelMessageQueue, ParseNodeInfoOptions, ParseUriResult, Protocol, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, Rfc9421SignRequestOptions, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityError, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, Services, SharedInboxKeyDispatcher, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, Software, UnverifiedActivityHandler, UnverifiedActivityReason, Usage, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, WebFingerHandlerParameters, WebFingerLinksDispatcher, actorDehydrator, attachSignature, autoIdAssigner, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, createProof, createSignature, detachSignature, digest, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getAuthenticatedDocumentLoader, getDefaultActivityTransformers, getKeyOwner, getNodeInfo, handleWebFinger, hasProofLike, hasSignatureLike, importJwk, kvCache, nodeInfoToJson, normalizeCircuitBreakerOptions, parseAcceptSignature, parseCircuitBreakerKvState, parseNodeInfo, respondWithObject, respondWithObjectIfAcceptable, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };
+  export { AcceptSignatureMember, AcceptSignatureParameters, ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CircuitBreaker, CircuitBreakerActivityDrop, CircuitBreakerBeforeSendDecision, CircuitBreakerCreateOptions, CircuitBreakerFailurePolicy, CircuitBreakerKvState, CircuitBreakerOptions, CircuitBreakerState, CircuitBreakerStateChange, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateProofOptions, CreateSignatureOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, DoesActorOwnKeyOptions, Federatable, Federation, FederationBenchmarkOptions, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, ForwardActivityOptions, FulfillAcceptSignatureResult, GetActorOptions, GetKeyOwnerOptions, GetNodeInfoOptions, GetSignedKeyOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboundService, InboxChallengePolicy, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, JsonValue, KeyCache, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, MemoryKvStore, Message, MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfo, NodeInfoDispatcher, NormalizedCircuitBreakerOptions, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboundService, OutboxContext, OutboxErrorHandler, OutboxListener, OutboxListenerErrorHandler, OutboxListenerSetters, OutboxPermanentFailureHandler, PageItems, ParallelMessageQueue, ParseNodeInfoOptions, ParseUriResult, Protocol, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, Rfc9421SignRequestOptions, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityError, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, Services, SharedInboxKeyDispatcher, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, Software, UnverifiedActivityHandler, UnverifiedActivityReason, Usage, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, WebFingerHandlerParameters, WebFingerLinksDispatcher, actorDehydrator, attachSignature, autoIdAssigner, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, createProof, createSignature, detachSignature, digest, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getAuthenticatedDocumentLoader, getDefaultActivityTransformers, getKeyOwner, getNodeInfo, handleWebFinger, hasProofLike, hasSignatureLike, importJwk, kvCache, nodeInfoToJson, normalizeCircuitBreakerOptions, parseAcceptSignature, parseCircuitBreakerKvState, parseNodeInfo, respondWithObject, respondWithObjectIfAcceptable, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };
 }
 //#endregion
-export { AcceptSignatureMember, AcceptSignatureParameters, ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CircuitBreaker, CircuitBreakerActivityDrop, CircuitBreakerBeforeSendDecision, CircuitBreakerCreateOptions, CircuitBreakerFailurePolicy, CircuitBreakerKvState, CircuitBreakerOptions, CircuitBreakerState, CircuitBreakerStateChange, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateProofOptions, CreateSignatureOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, DoesActorOwnKeyOptions, Federatable, Federation, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, ForwardActivityOptions, FulfillAcceptSignatureResult, GetActorOptions, GetKeyOwnerOptions, GetNodeInfoOptions, GetSignedKeyOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboundService, InboxChallengePolicy, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, JsonValue, KeyCache, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, MemoryKvStore, Message, MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfo, NodeInfoDispatcher, NormalizedCircuitBreakerOptions, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboundService, OutboxContext, OutboxErrorHandler, OutboxListener, OutboxListenerErrorHandler, OutboxListenerSetters, OutboxPermanentFailureHandler, PageItems, ParallelMessageQueue, ParseNodeInfoOptions, ParseUriResult, Protocol, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, Rfc9421SignRequestOptions, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityError, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, Services, SharedInboxKeyDispatcher, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, Software, UnverifiedActivityHandler, UnverifiedActivityReason, Usage, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, WebFingerHandlerParameters, WebFingerLinksDispatcher, actorDehydrator, attachSignature, autoIdAssigner, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, createProof, createSignature, detachSignature, digest, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getAuthenticatedDocumentLoader, getDefaultActivityTransformers, getKeyOwner, getNodeInfo, handleWebFinger, hasProofLike, hasSignatureLike, importJwk, kvCache, nodeInfoToJson, normalizeCircuitBreakerOptions, parseAcceptSignature, parseCircuitBreakerKvState, parseNodeInfo, respondWithObject, respondWithObjectIfAcceptable, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };
+export { AcceptSignatureMember, AcceptSignatureParameters, ActivityTransformer, ActorAliasMapper, ActorCallbackSetters, ActorDispatcher, ActorHandleMapper, ActorKeyPair, ActorKeyPairsDispatcher, AuthorizePredicate, CircuitBreaker, CircuitBreakerActivityDrop, CircuitBreakerBeforeSendDecision, CircuitBreakerCreateOptions, CircuitBreakerFailurePolicy, CircuitBreakerKvState, CircuitBreakerOptions, CircuitBreakerState, CircuitBreakerStateChange, CollectionCallbackSetters, CollectionCounter, CollectionCursor, CollectionDispatcher, ConstructorWithTypeId, Context, CreateExponentialBackoffPolicyOptions, CreateProofOptions, CreateSignatureOptions, CustomCollectionCallbackSetters, CustomCollectionCounter, CustomCollectionCursor, CustomCollectionDispatcher, DoesActorOwnKeyOptions, Federatable, Federation, FederationBenchmarkOptions, FederationBuilder, FederationFetchOptions, FederationKvPrefixes, FederationOptions, FederationOrigin, FederationQueueOptions, FederationStartQueueOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, ForwardActivityOptions, FulfillAcceptSignatureResult, GetActorOptions, GetKeyOwnerOptions, GetNodeInfoOptions, GetSignedKeyOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, IdempotencyKeyCallback, IdempotencyStrategy, InProcessMessageQueue, InProcessMessageQueueOptions, InboundService, InboxChallengePolicy, InboxContext, InboxErrorHandler, InboxListener, InboxListenerSetters, JsonValue, KeyCache, KvKey, KvStore, KvStoreListEntry, KvStoreSetOptions, MemoryKvStore, Message, MessageQueue, MessageQueueDepth, MessageQueueEnqueueOptions, MessageQueueListenOptions, NodeInfo, NodeInfoDispatcher, NormalizedCircuitBreakerOptions, ObjectAuthorizePredicate, ObjectCallbackSetters, ObjectDispatcher, OutboundService, OutboxContext, OutboxErrorHandler, OutboxListener, OutboxListenerErrorHandler, OutboxListenerSetters, OutboxPermanentFailureHandler, PageItems, ParallelMessageQueue, ParseNodeInfoOptions, ParseUriResult, Protocol, RequestContext, RespondWithObjectOptions, RetryContext, RetryPolicy, Rfc6570Expression, Rfc9421SignRequestOptions, RouteActivityOptions, Router, RouterError, RouterOptions, RouterRouteResult, SendActivityError, SendActivityOptions, SendActivityOptionsForCollection, SenderKeyPair, Services, SharedInboxKeyDispatcher, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, Software, UnverifiedActivityHandler, UnverifiedActivityReason, Usage, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, WebFingerHandlerParameters, WebFingerLinksDispatcher, actorDehydrator, attachSignature, autoIdAssigner, buildCollectionSynchronizationHeader, createExponentialBackoffPolicy, createFederation, createFederationBuilder, createProof, createSignature, detachSignature, digest, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getAuthenticatedDocumentLoader, getDefaultActivityTransformers, getKeyOwner, getNodeInfo, handleWebFinger, hasProofLike, hasSignatureLike, importJwk, kvCache, nodeInfoToJson, normalizeCircuitBreakerOptions, parseAcceptSignature, parseCircuitBreakerKvState, parseNodeInfo, respondWithObject, respondWithObjectIfAcceptable, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };