@fedify/fedify 1.6.1-dev.869 → 1.6.1-dev.871

package/dist/{federation/inbox.js → inbox-XV_W1qfB.js}

@@ -1,10 +1,11 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { deno_default } from "../deno.js";
-import { getTypeId } from "../vocab/type.js";
-import { Activity } from "../vocab/vocab.js";
+import { deno_default } from "./docloader-BcMxZ9JH.js";
+import { Activity } from "./vocab-BxrrllKY.js";
+import { getTypeId } from "./type-D2s5lmbZ.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, context, propagation, trace } from "@opentelemetry/api";
 

package/dist/key-BNM-ickE.js

@@ -0,0 +1,16 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import "./docloader-BcMxZ9JH.js";
+import "./url-kTAI6_KP.js";
+import "./multibase-DeCHcK8L.js";
+import "./vocab-BxrrllKY.js";
+import "./langstr-DbWheeIS.js";
+import "./lookup-D3xTID-6.js";
+import "./type-D2s5lmbZ.js";
+import "./actor-D7NMuy45.js";
+import { exportJwk, fetchKey, generateCryptoKeyPair, importJwk, validateCryptoKey } from "./key-CVIQ7iUB.js";
+
+export { validateCryptoKey };

package/dist/key-CVIQ7iUB.js

@@ -0,0 +1,262 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { deno_default, getDocumentLoader } from "./docloader-BcMxZ9JH.js";
+import { CryptographicKey, Object as Object$1 } from "./vocab-BxrrllKY.js";
+import { isActor } from "./actor-D7NMuy45.js";
+import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+
+//#region sig/key.ts
+/**
+* Checks if the given key is valid and supported.  No-op if the key is valid,
+* otherwise throws an error.
+* @param key The key to check.
+* @param type Which type of key to check.  If not specified, the key can be
+*             either public or private.
+* @throws {TypeError} If the key is invalid or unsupported.
+*/
+function validateCryptoKey(key, type) {
+	if (type != null && key.type !== type) throw new TypeError(`The key is not a ${type} key.`);
+	if (!key.extractable) throw new TypeError("The key is not extractable.");
+	if (key.algorithm.name !== "RSASSA-PKCS1-v1_5" && key.algorithm.name !== "Ed25519") throw new TypeError("Currently only RSASSA-PKCS1-v1_5 and Ed25519 keys are supported.  More algorithms will be added in the future!");
+	if (key.algorithm.name === "RSASSA-PKCS1-v1_5") {
+		const algorithm = key.algorithm;
+		if (algorithm.hash.name !== "SHA-256") throw new TypeError("For compatibility with the existing Fediverse software (e.g., Mastodon), hash algorithm for RSASSA-PKCS1-v1_5 keys must be SHA-256.");
+	}
+}
+/**
+* Generates a key pair which is appropriate for Fedify.
+* @param algorithm The algorithm to use.  Currently only RSASSA-PKCS1-v1_5 and
+*                  Ed25519 are supported.
+* @returns The generated key pair.
+* @throws {TypeError} If the algorithm is unsupported.
+*/
+function generateCryptoKeyPair(algorithm) {
+	if (algorithm == null) getLogger([
+		"fedify",
+		"sig",
+		"key"
+	]).warn("No algorithm specified.  Using RSASSA-PKCS1-v1_5 by default, but it is recommended to specify the algorithm explicitly as the parameter will be required in the future.");
+	if (algorithm == null || algorithm === "RSASSA-PKCS1-v1_5") return crypto.subtle.generateKey({
+		name: "RSASSA-PKCS1-v1_5",
+		modulusLength: 4096,
+		publicExponent: new Uint8Array([
+			1,
+			0,
+			1
+		]),
+		hash: "SHA-256"
+	}, true, ["sign", "verify"]);
+	else if (algorithm === "Ed25519") return crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"]);
+	throw new TypeError("Unsupported algorithm: " + algorithm);
+}
+/**
+* Exports a key in JWK format.
+* @param key The key to export.  Either public or private key.
+* @returns The exported key in JWK format.  The key is suitable for
+*          serialization and storage.
+* @throws {TypeError} If the key is invalid or unsupported.
+*/
+async function exportJwk(key) {
+	validateCryptoKey(key);
+	const jwk = await crypto.subtle.exportKey("jwk", key);
+	if (jwk.crv === "Ed25519") jwk.alg = "Ed25519";
+	return jwk;
+}
+/**
+* Imports a key from JWK format.
+* @param jwk The key in JWK format.
+* @param type Which type of key to import, either `"public"` or `"private"`.
+* @returns The imported key.
+* @throws {TypeError} If the key is invalid or unsupported.
+*/
+async function importJwk(jwk, type) {
+	let key;
+	if (jwk.kty === "RSA" && jwk.alg === "RS256") key = await crypto.subtle.importKey("jwk", jwk, {
+		name: "RSASSA-PKCS1-v1_5",
+		hash: "SHA-256"
+	}, true, type === "public" ? ["verify"] : ["sign"]);
+	else if (jwk.kty === "OKP" && jwk.crv === "Ed25519") {
+		if (navigator?.userAgent === "Cloudflare-Workers") {
+			jwk = { ...jwk };
+			delete jwk.alg;
+		}
+		key = await crypto.subtle.importKey("jwk", jwk, "Ed25519", true, type === "public" ? ["verify"] : ["sign"]);
+	} else throw new TypeError("Unsupported JWK format.");
+	validateCryptoKey(key, type);
+	return key;
+}
+/**
+* Fetches a {@link CryptographicKey} or {@link Multikey} from the given URL.
+* If the given URL contains an {@link Actor} object, it tries to find
+* the corresponding key in the `publicKey` or `assertionMethod` property.
+* @typeParam T The type of the key to fetch.  Either {@link CryptographicKey}
+*              or {@link Multikey}.
+* @param keyId The URL of the key.
+* @param cls The class of the key to fetch.  Either {@link CryptographicKey}
+*            or {@link Multikey}.
+* @param options Options for fetching the key.  See {@link FetchKeyOptions}.
+* @returns The fetched key or `null` if the key is not found.
+* @since 1.3.0
+*/
+function fetchKey(keyId, cls, options = {}) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	keyId = typeof keyId === "string" ? new URL(keyId) : keyId;
+	return tracer.startActiveSpan("activitypub.fetch_key", {
+		kind: SpanKind.CLIENT,
+		attributes: {
+			"http.method": "GET",
+			"url.full": keyId.href,
+			"url.scheme": keyId.protocol.replace(/:$/, ""),
+			"url.domain": keyId.hostname,
+			"url.path": keyId.pathname,
+			"url.query": keyId.search.replace(/^\?/, ""),
+			"url.fragment": keyId.hash.replace(/^#/, "")
+		}
+	}, async (span) => {
+		try {
+			const result = await fetchKeyInternal(keyId, cls, options);
+			span.setAttribute("activitypub.actor.key.cached", result.cached);
+			return result;
+		} catch (e) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(e)
+			});
+			throw e;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function fetchKeyInternal(keyId, cls, { documentLoader, contextLoader, keyCache, tracerProvider } = {}) {
+	const logger = getLogger([
+		"fedify",
+		"sig",
+		"key"
+	]);
+	const cacheKey = typeof keyId === "string" ? new URL(keyId) : keyId;
+	keyId = typeof keyId === "string" ? keyId : keyId.href;
+	if (keyCache != null) {
+		const cachedKey = await keyCache.get(cacheKey);
+		if (cachedKey instanceof cls && cachedKey.publicKey != null) {
+			logger.debug("Key {keyId} found in cache.", { keyId });
+			return {
+				key: cachedKey,
+				cached: true
+			};
+		} else if (cachedKey === null) {
+			logger.debug("Entry {keyId} found in cache, but it is unavailable.", { keyId });
+			return {
+				key: null,
+				cached: true
+			};
+		}
+	}
+	logger.debug("Fetching key {keyId} to verify signature...", { keyId });
+	let document;
+	try {
+		const remoteDocument = await (documentLoader ?? getDocumentLoader())(keyId);
+		document = remoteDocument.document;
+	} catch (_) {
+		logger.debug("Failed to fetch key {keyId}.", { keyId });
+		await keyCache?.set(cacheKey, null);
+		return {
+			key: null,
+			cached: false
+		};
+	}
+	let object;
+	try {
+		object = await Object$1.fromJsonLd(document, {
+			documentLoader,
+			contextLoader,
+			tracerProvider
+		});
+	} catch (e) {
+		if (!(e instanceof TypeError)) throw e;
+		try {
+			object = await cls.fromJsonLd(document, {
+				documentLoader,
+				contextLoader,
+				tracerProvider
+			});
+		} catch (e$1) {
+			if (e$1 instanceof TypeError) {
+				logger.debug("Failed to verify; key {keyId} returned an invalid object.", { keyId });
+				await keyCache?.set(cacheKey, null);
+				return {
+					key: null,
+					cached: false
+				};
+			}
+			throw e$1;
+		}
+	}
+	let key = null;
+	if (object instanceof cls) key = object;
+	else if (isActor(object)) {
+		const keys = cls === CryptographicKey ? object.getPublicKeys({
+			documentLoader,
+			contextLoader,
+			tracerProvider
+		}) : object.getAssertionMethods({
+			documentLoader,
+			contextLoader,
+			tracerProvider
+		});
+		let length = 0;
+		let lastKey = null;
+		for await (const k of keys) {
+			length++;
+			lastKey = k;
+			if (k.id?.href === keyId) {
+				key = k;
+				break;
+			}
+		}
+		const keyIdUrl = new URL(keyId);
+		if (key == null && keyIdUrl.hash === "" && length === 1) key = lastKey;
+		if (key == null) {
+			logger.debug("Failed to verify; object {keyId} returned an {actorType}, but has no key matching {keyId}.", {
+				keyId,
+				actorType: object.constructor.name
+			});
+			await keyCache?.set(cacheKey, null);
+			return {
+				key: null,
+				cached: false
+			};
+		}
+	} else {
+		logger.debug("Failed to verify; key {keyId} returned an invalid object.", { keyId });
+		await keyCache?.set(cacheKey, null);
+		return {
+			key: null,
+			cached: false
+		};
+	}
+	if (key.publicKey == null) {
+		logger.debug("Failed to verify; key {keyId} has no publicKeyPem field.", { keyId });
+		await keyCache?.set(cacheKey, null);
+		return {
+			key: null,
+			cached: false
+		};
+	}
+	if (keyCache != null) {
+		await keyCache.set(cacheKey, key);
+		logger.debug("Key {keyId} cached.", { keyId });
+	}
+	return {
+		key,
+		cached: false
+	};
+}
+
+//#endregion
+export { exportJwk, fetchKey, generateCryptoKeyPair, importJwk, validateCryptoKey };

package/dist/{sig/key.js → key-DIk4Rloj.js}

@@ -2,10 +2,8 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { deno_default } from "../deno.js";
-import { getDocumentLoader } from "../runtime/docloader.js";
-import { CryptographicKey, Object as Object$1 } from "../vocab/vocab.js";
-import { isActor } from "../vocab/actor.js";
+import { deno_default, getDocumentLoader } from "./docloader-DDFam5Xn.js";
+import { CryptographicKey, Object as Object$1, isActor } from "./actor-CM3gfkH6.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 

package/dist/key-DiVhk5ik.js

@@ -0,0 +1,10 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import "./docloader-DDFam5Xn.js";
+import "./actor-CM3gfkH6.js";
+import "./lookup-B5KVF6HM.js";
+import { exportJwk, fetchKey, generateCryptoKeyPair, importJwk, validateCryptoKey } from "./key-DIk4Rloj.js";
+
+export { validateCryptoKey };

package/dist/{federation/keycache.js → keycache-uTxsh7dt.js}

@@ -1,8 +1,9 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { CryptographicKey, Multikey } from "../vocab/vocab.js";
+import { CryptographicKey, Multikey } from "./vocab-BxrrllKY.js";
 
 //#region federation/keycache.ts
 var KvKeyCache = class {

package/dist/{testing/keys.js → keys-D7lJqunm.js}

@@ -1,9 +1,9 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { importSpki } from "../runtime/key.js";
-import { CryptographicKey, Multikey } from "../vocab/vocab.js";
+import { CryptographicKey, Multikey, importSpki } from "./vocab-BxrrllKY.js";
 
 //#region testing/keys.ts
 const rsaPublicKey1 = new CryptographicKey({

package/dist/{federation/kv.js → kv-DohFOP2C.js}

@@ -1,6 +1,7 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
 //#region federation/kv.ts
 /**

package/dist/{runtime/langstr.js → langstr-DbWheeIS.js}

@@ -1,6 +1,7 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
 import { parseLanguageTag } from "@phensley/language-tag";
 

package/dist/{sig/ld.js → ld-bOhcKpmk.js}

@@ -1,17 +1,17 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { deno_default } from "../deno.js";
-import { getTypeId } from "../vocab/type.js";
-import { getDocumentLoader } from "../runtime/docloader.js";
-import { Activity, CryptographicKey, Object as Object$1 } from "../vocab/vocab.js";
-import { fetchKey, validateCryptoKey } from "./key.js";
+import { deno_default, getDocumentLoader } from "./docloader-BcMxZ9JH.js";
+import { Activity, CryptographicKey, Object as Object$1 } from "./vocab-BxrrllKY.js";
+import { getTypeId } from "./type-D2s5lmbZ.js";
+import { fetchKey, validateCryptoKey } from "./key-CVIQ7iUB.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
-import jsonld from "jsonld";
 import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
 import { encodeHex } from "byte-encodings/hex";
+import jsonld from "jsonld";
 
 //#region sig/ld.ts
 const logger = getLogger([

package/dist/{webfinger/lookup.js → lookup-B5KVF6HM.js}

@@ -2,9 +2,7 @@
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
     
-import { deno_default } from "../deno.js";
-import { UrlError, validatePublicUrl } from "../runtime/url.js";
-import { getUserAgent } from "../runtime/docloader.js";
+import { UrlError, deno_default, getUserAgent, validatePublicUrl } from "./docloader-DDFam5Xn.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 

package/dist/lookup-D3xTID-6.js

@@ -0,0 +1,131 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { deno_default, getUserAgent } from "./docloader-BcMxZ9JH.js";
+import { UrlError, validatePublicUrl } from "./url-kTAI6_KP.js";
+import { getLogger } from "@logtape/logtape";
+import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
+
+//#region webfinger/lookup.ts
+const logger = getLogger([
+	"fedify",
+	"webfinger",
+	"lookup"
+]);
+const MAX_REDIRECTION = 5;
+/**
+* Looks up a WebFinger resource.
+* @param resource The resource URL to look up.
+* @param options Extra options for looking up the resource.
+* @returns The resource descriptor, or `null` if not found.
+* @since 0.2.0
+*/
+async function lookupWebFinger(resource, options = {}) {
+	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+	const tracer = tracerProvider.getTracer(deno_default.name, deno_default.version);
+	return await tracer.startActiveSpan("webfinger.lookup", {
+		kind: SpanKind.CLIENT,
+		attributes: {
+			"webfinger.resource": resource.toString(),
+			"webfinger.resource.scheme": typeof resource === "string" ? resource.replace(/:.*$/, "") : resource.protocol.replace(/:$/, "")
+		}
+	}, async (span) => {
+		try {
+			const result = await lookupWebFingerInternal(resource, options);
+			span.setStatus({ code: result === null ? SpanStatusCode.ERROR : SpanStatusCode.OK });
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function lookupWebFingerInternal(resource, options = {}) {
+	if (typeof resource === "string") resource = new URL(resource);
+	let protocol = "https:";
+	let server;
+	if (resource.protocol === "acct:") {
+		const atPos = resource.pathname.lastIndexOf("@");
+		if (atPos < 0) return null;
+		server = resource.pathname.substring(atPos + 1);
+		if (server === "") return null;
+	} else {
+		protocol = resource.protocol;
+		server = resource.host;
+	}
+	let url = new URL(`${protocol}//${server}/.well-known/webfinger`);
+	url.searchParams.set("resource", resource.href);
+	let redirected = 0;
+	while (true) {
+		logger.debug("Fetching WebFinger resource descriptor from {url}...", { url: url.href });
+		let response;
+		if (options.allowPrivateAddress !== true) try {
+			await validatePublicUrl(url.href);
+		} catch (e) {
+			if (e instanceof UrlError) {
+				logger.error("Invalid URL for WebFinger resource descriptor: {error}", { error: e });
+				return null;
+			}
+			throw e;
+		}
+		try {
+			response = await fetch(url, {
+				headers: {
+					Accept: "application/jrd+json",
+					"User-Agent": typeof options.userAgent === "string" ? options.userAgent : getUserAgent(options.userAgent)
+				},
+				redirect: "manual"
+			});
+		} catch (error) {
+			logger.debug("Failed to fetch WebFinger resource descriptor: {error}", {
+				url: url.href,
+				error
+			});
+			return null;
+		}
+		if (response.status >= 300 && response.status < 400 && response.headers.has("Location")) {
+			redirected++;
+			if (redirected >= MAX_REDIRECTION) {
+				logger.error("Too many redirections ({redirections}) while fetching WebFinger resource descriptor.", { redirections: redirected });
+				return null;
+			}
+			const redirectedUrl = new URL(response.headers.get("Location"), response.url == null || response.url === "" ? url : response.url);
+			if (redirectedUrl.protocol !== url.protocol) {
+				logger.error("Redirected to a different protocol ({protocol} to {redirectedProtocol}) while fetching WebFinger resource descriptor.", {
+					protocol: url.protocol,
+					redirectedProtocol: redirectedUrl.protocol
+				});
+				return null;
+			}
+			url = redirectedUrl;
+			continue;
+		}
+		if (!response.ok) {
+			logger.debug("Failed to fetch WebFinger resource descriptor: {status} {statusText}.", {
+				url: url.href,
+				status: response.status,
+				statusText: response.statusText
+			});
+			return null;
+		}
+		try {
+			return await response.json();
+		} catch (e) {
+			if (e instanceof SyntaxError) {
+				logger.debug("Failed to parse WebFinger resource descriptor as JSON: {error}", { error: e });
+				return null;
+			}
+			throw e;
+		}
+	}
+}
+
+//#endregion
+export { lookupWebFinger };

package/dist/{webfinger/jrd.d.ts → lookup-DAfStZtI.d.ts}

@@ -1,5 +1,7 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
+import { GetUserAgentOptions } from "./docloader-DTRsVZPo.js";
+import { TracerProvider } from "@opentelemetry/api";
 
 //#region webfinger/jrd.d.ts
 /**
@@ -57,4 +59,42 @@ interface Link {
    */
   properties?: Record<string, string>;
 } //#endregion
-export { Link as Link$1, ResourceDescriptor };
+//#region webfinger/lookup.d.ts
+/**
+ * Options for {@link lookupWebFinger}.
+ * @since 1.3.0
+ */
+interface LookupWebFingerOptions {
+  /**
+   * The options for making `User-Agent` header.
+   * If a string is given, it is used as the `User-Agent` header value.
+   * If an object is given, it is passed to {@link getUserAgent} to generate
+   * the `User-Agent` header value.
+   */
+  userAgent?: GetUserAgentOptions | string;
+  /**
+   * Whether to allow private IP addresses in the URL.
+   *
+   * Mostly useful for testing purposes.  *Do not use this in production.*
+   *
+   * Turned off by default.
+   * @since 1.4.0
+   */
+  allowPrivateAddress?: boolean;
+  /**
+   * The OpenTelemetry tracer provider.  If omitted, the global tracer provider
+   * is used.
+   */
+  tracerProvider?: TracerProvider;
+}
+/**
+ * Looks up a WebFinger resource.
+ * @param resource The resource URL to look up.
+ * @param options Extra options for looking up the resource.
+ * @returns The resource descriptor, or `null` if not found.
+ * @since 0.2.0
+ */
+declare function lookupWebFinger(resource: URL | string, options?: LookupWebFingerOptions): Promise<ResourceDescriptor | null>;
+
+//#endregion
+export { Link as Link$2, LookupWebFingerOptions, ResourceDescriptor, lookupWebFinger as lookupWebFinger$1 };

package/dist/{vocab/lookup.js → lookup-D_v0FFGL.js}

@@ -1,12 +1,12 @@
 
       import { Temporal } from "@js-temporal/polyfill";
       import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
     
-import { deno_default } from "../deno.js";
-import { getTypeId } from "./type.js";
-import { getDocumentLoader } from "../runtime/docloader.js";
-import { Object as Object$1 } from "./vocab.js";
-import { lookupWebFinger } from "../webfinger/lookup.js";
+import { deno_default, getDocumentLoader } from "./docloader-BcMxZ9JH.js";
+import { Object as Object$1 } from "./vocab-BxrrllKY.js";
+import { lookupWebFinger } from "./lookup-D3xTID-6.js";
+import { getTypeId } from "./type-D2s5lmbZ.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { delay } from "@es-toolkit/es-toolkit";

package/dist/middleware-BFedQWFA.js

@@ -0,0 +1,33 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { ContextImpl, FederationImpl, InboxContextImpl, KvSpecDeterminer, createFederation } from "./middleware-CPAfRtS5.js";
+import "./docloader-BcMxZ9JH.js";
+import "./url-kTAI6_KP.js";
+import "./semver-CbbIgUsa.js";
+import "./client-RN5A1Qgw.js";
+import "./router-D_aVZZUc.js";
+import "./types-CqoqWDkp.js";
+import "./multibase-DeCHcK8L.js";
+import "./vocab-BxrrllKY.js";
+import "./langstr-DbWheeIS.js";
+import "./lookup-D3xTID-6.js";
+import "./type-D2s5lmbZ.js";
+import "./actor-D7NMuy45.js";
+import "./key-CVIQ7iUB.js";
+import "./http-BFvv3ZId.js";
+import "./authdocloader-BKZDAq91.js";
+import "./ld-bOhcKpmk.js";
+import "./owner-tYPzPLFs.js";
+import "./proof-DIsZ1VTb.js";
+import "./lookup-D_v0FFGL.js";
+import "./inbox-XV_W1qfB.js";
+import "./builder-DSTiU6ue.js";
+import "./collection-QaGK9TVn.js";
+import "./keycache-uTxsh7dt.js";
+import "./retry-BiIhZWgD.js";
+import "./send-CFBOnY61.js";
+
+export { FederationImpl };