@fedify/fedify 2.4.0-dev.2065 → 2.4.0-dev.2073

package/dist/owner-BLBWXCNt.js

@@ -1,2276 +0,0 @@
-import { Temporal } from "temporal-polyfill";
-import { URLPattern } from "urlpattern-polyfill";
-import { I as name, L as version, c as fetchKey, f as validateCryptoKey, h as getFederationMetrics, m as getDurationMs, o as exportJwk, p as verifyKeyOwnership, s as fetchActorDocument, y as measureSignatureKeyFetch } from "./http-z5n7chWw.js";
-import { getLogger } from "@logtape/logtape";
-import { Activity, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1, PUBLIC_COLLECTION, getTypeId, isActor } from "@fedify/vocab";
-import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
-import { encodeHex } from "byte-encodings/hex";
-import { encodeMultibase, formatIri, getDocumentLoader, getFe34Origin, haveSameFe34Origin, parseIri, preloadedContexts } from "@fedify/vocab-runtime";
-import jsonld from "@fedify/vocab-runtime/jsonld";
-import { isPlainJsonTree, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";
-import serialize from "json-canon";
-import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
-//#region src/compat/preloaded-context-loader.ts
-/**
-* A restricted JSON-LD document loader that resolves only contexts bundled
-* with Fedify.
-*
-* This is intentionally narrower than `getDocumentLoader()`: normalization
-* helpers are also reached from verification paths that operate on inbound,
-* attacker-controlled JSON-LD, so the default fallback must never fetch
-* attacker-supplied context URLs.
-*/
-const preloadedOnlyDocumentLoader = (url) => {
-	if (Object.hasOwn(preloadedContexts, url)) return Promise.resolve({
-		contextUrl: null,
-		documentUrl: url,
-		document: preloadedContexts[url]
-	});
-	return Promise.reject(/* @__PURE__ */ new Error("Refusing to fetch a non-preloaded JSON-LD context: " + url));
-};
-//#endregion
-//#region src/compat/secured-document.ts
-function isJsonMap$1(value) {
-	return typeof value === "object" && value != null && !Array.isArray(value);
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
-function hasDataIntegrityProofType(value) {
-	return (Array.isArray(value) ? value : [value]).some((type) => type === "DataIntegrityProof" || type === "https://w3id.org/security#DataIntegrityProof");
-}
-/**
-* Checks whether a JSON value is a complete, self-contained secured document:
-* a map with its own `@context` and exactly one direct, map-valued `proof`
-* that carries every member `eddsa-jcs-2022` proof generation produces.
-*
-* This is deliberately stricter than {@link hasProofLike}, which exists to
-* decide whether a document is worth verifying.  Here a false positive would
-* silently suppress a wire-compatibility fix on an ordinary document, so a
-* partial or malformed proof does not qualify.
-*
-* @internal
-*/
-function isSelfContainedSecuredDocument(value) {
-	if (!isJsonMap$1(value)) return false;
-	if (!Object.hasOwn(value, "@context") || value["@context"] == null) return false;
-	if (!Object.hasOwn(value, "proof")) return false;
-	const proof = value.proof;
-	if (!isJsonMap$1(proof)) return false;
-	return hasDataIntegrityProofType(proof.type) && isNonEmptyString(proof.cryptosuite) && isNonEmptyString(proof.created) && isNonEmptyString(proof.verificationMethod) && isNonEmptyString(proof.proofPurpose) && isNonEmptyString(proof.proofValue);
-}
-//#endregion
-//#region src/compat/public-audience.ts
-const logger$4 = getLogger([
-	"fedify",
-	"compat",
-	"public-audience"
-]);
-const PUBLIC_ADDRESSING_FIELDS = /* @__PURE__ */ new Set([
-	"to",
-	"cc",
-	"bto",
-	"bcc",
-	"audience"
-]);
-const AS_CONTEXT_URL$1 = "https://www.w3.org/ns/activitystreams";
-const MAX_TRAVERSAL_DEPTH$1 = 64;
-const KNOWN_SAFE_CONTEXT_URLS$1 = new Set(Object.keys(preloadedContexts));
-function hasPublicCurieInAddressing(value, preserveSecured, parentKey, depth = 0) {
-	if (typeof value === "string") return parentKey != null && PUBLIC_ADDRESSING_FIELDS.has(parentKey) && (value === "as:Public" || value === "Public");
-	if (depth >= MAX_TRAVERSAL_DEPTH$1) return false;
-	if (Array.isArray(value)) return value.some((item) => hasPublicCurieInAddressing(item, preserveSecured, parentKey, depth + 1));
-	if (typeof value !== "object" || value == null) return false;
-	if (preserveSecured && depth > 0 && isSelfContainedSecuredDocument(value)) return false;
-	const record = value;
-	for (const key of Object.keys(record)) {
-		if (record.type === "Follow" && key === "object" && (record[key] === "as:Public" || record[key] === "Public")) return true;
-		if (key === "@context") continue;
-		if (hasPublicCurieInAddressing(record[key], preserveSecured, key, depth + 1)) return true;
-	}
-	return false;
-}
-function rewritePublicAudience(value, preserveSecured, parentKey, depth = 0) {
-	if (typeof value === "string" && parentKey != null && PUBLIC_ADDRESSING_FIELDS.has(parentKey) && (value === "as:Public" || value === "Public")) return PUBLIC_COLLECTION.href;
-	if (depth >= MAX_TRAVERSAL_DEPTH$1) return value;
-	if (Array.isArray(value)) {
-		let changed = false;
-		const mapped = value.map((item) => {
-			const rewritten = rewritePublicAudience(item, preserveSecured, parentKey, depth + 1);
-			if (rewritten !== item) changed = true;
-			return rewritten;
-		});
-		return changed ? mapped : value;
-	}
-	if (typeof value !== "object" || value == null) return value;
-	if (preserveSecured && depth > 0 && isSelfContainedSecuredDocument(value)) return value;
-	const record = value;
-	let changed = false;
-	const normalized = Object.create(null);
-	for (const key of Object.keys(record)) {
-		const rewritten = key === "@context" ? record[key] : record.type === "Follow" && key === "object" && (record[key] === "as:Public" || record[key] === "Public") ? PUBLIC_COLLECTION.href : rewritePublicAudience(record[key], preserveSecured, key, depth + 1);
-		if (rewritten !== record[key]) changed = true;
-		normalized[key] = rewritten;
-	}
-	return changed ? normalized : value;
-}
-/**
-* Reports whether `value` carries an `@context` property anywhere inside
-* its subtree (not counting the value itself).  A nested `@context` can
-* introduce a local term-definition scope that redefines `as:` or `Public`
-* even when the top-level `@context` is safe, so the fast path must defer
-* to the URDNA2015 equivalence check whenever one is present.
-*/
-function hasNestedContext$1(value, depth = 0) {
-	if (depth >= MAX_TRAVERSAL_DEPTH$1) return true;
-	if (Array.isArray(value)) return value.some((item) => hasNestedContext$1(item, depth + 1));
-	if (typeof value !== "object" || value == null) return false;
-	const record = value;
-	for (const key of Object.keys(record)) {
-		if (key === "@context") return true;
-		if (hasNestedContext$1(record[key], depth + 1)) return true;
-	}
-	return false;
-}
-/**
-* Checks whether the `@context` of a JSON-LD document is guaranteed not
-* to redefine the `as:` prefix or the bare `Public` term.  Only documents
-* whose `@context` is a string, or an array of strings, drawn from Fedify's
-* preloaded context set AND including the ActivityStreams URL qualify,
-* AND no nested subtree carries its own `@context` that might redefine
-* those terms within a local scope.  When all of that holds the rewrite
-* is provably semantics-preserving and the URDNA2015 equivalence check
-* can be skipped.  Any other shape (unknown external URLs, inline
-* objects at the top level, nested `@context` blocks) is treated as
-* potentially unsafe.
-*/
-function hasKnownSafeContext$1(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return false;
-	const record = jsonLd;
-	if (!Object.hasOwn(record, "@context")) return false;
-	const ctx = record["@context"];
-	const entries = typeof ctx === "string" ? [ctx] : Array.isArray(ctx) ? ctx : null;
-	if (entries == null || entries.length === 0) return false;
-	let hasAs = false;
-	for (const entry of entries) {
-		if (typeof entry !== "string") return false;
-		if (!KNOWN_SAFE_CONTEXT_URLS$1.has(entry)) return false;
-		if (entry === AS_CONTEXT_URL$1) hasAs = true;
-	}
-	if (!hasAs) return false;
-	for (const key of Object.keys(record)) {
-		if (key === "@context") continue;
-		if (hasNestedContext$1(record[key])) return false;
-	}
-	return true;
-}
-/**
-* Rewrites the compact `as:Public` / `Public` CURIE appearing in activity
-* addressing fields (`to`, `cc`, `bto`, `bcc`, `audience`) to the fully
-* expanded `https://www.w3.org/ns/activitystreams#Public` URI.
-*
-* Several ActivityPub implementations, Lemmy among them, match these
-* fields as plain URLs without running JSON-LD expansion, and silently
-* drop activities whose public addressing appears in CURIE form.  This
-* helper works around that gap.
-*
-* For documents whose `@context` is drawn entirely from Fedify's
-* preloaded context set and includes the ActivityStreams URL, the
-* rewrite is applied directly: the content of every preloaded non-AS
-* context is known not to redefine the `as:` prefix or the bare `Public`
-* term, so the semantics are preserved by construction.  Any other
-* shape (an inline object, an unknown external URL, and so on) is
-* treated as potentially unsafe and gated on a JSON-LD equivalence
-* check; both forms are canonicalized with URDNA2015 and the resulting
-* N-Quads are compared.  When they differ, the original document is
-* returned unchanged.  Canonicalization failures also fall back to the
-* original document.
-*
-* When no `contextLoader` is supplied the helper falls back to an
-* internal loader that resolves only the URLs in Fedify's
-* preloaded-contexts set and rejects every other URL without issuing a
-* network request.  That behaviour is deliberately narrower than
-* `@fedify/vocab-runtime`'s `getDocumentLoader()`, which after its
-* `validatePublicUrl` check will happily fetch non-preloaded URLs: the
-* helper is reached from verification paths (`verifyProof()` /
-* `verifyObject()`) that operate on inbound, potentially adversarial
-* JSON-LD, and a default loader that fetches attacker-supplied
-* `@context` URLs on the caller's behalf would be an SSRF vector.
-* Canonicalization failures against the restricted loader fall back to
-* the original document, same as any other canonicalization error.
-* Callers that genuinely need the remote-fetch loader (for example
-* applications that sign local JSON-LD against a custom vocabulary)
-* should pass a `contextLoader` explicitly.
-*
-* Must be called before any signing step that canonicalizes the
-* compact form byte-for-byte (for example, Object Integrity Proofs
-* using the `eddsa-jcs-2022` cryptosuite), so the signed payload
-* matches what is sent on the wire.
-*/
-async function normalizePublicAudience(jsonLd, contextLoader, options = {}) {
-	const preserveSecured = options.preserveNestedSecuredDocuments ?? false;
-	if (!hasPublicCurieInAddressing(jsonLd, preserveSecured)) return jsonLd;
-	const normalized = rewritePublicAudience(jsonLd, preserveSecured);
-	if (hasKnownSafeContext$1(jsonLd)) return normalized;
-	const loader = contextLoader ?? preloadedOnlyDocumentLoader;
-	try {
-		const [before, after] = await Promise.all([jsonld.canonize(jsonLd, {
-			format: "application/n-quads",
-			documentLoader: loader
-		}), jsonld.canonize(normalized, {
-			format: "application/n-quads",
-			documentLoader: loader
-		})]);
-		if (before === after) return normalized;
-		logger$4.warn("Expanding the public audience CURIE to its full URI would change the canonical form of the activity; sending the activity as is.  This usually means the active JSON-LD context redefines the `as:` prefix or the bare `Public` term.");
-	} catch (error) {
-		logger$4.debug("Failed to verify public audience normalization equivalence via JSON-LD canonicalization; sending the activity as is.\n{error}", { error });
-	}
-	return jsonLd;
-}
-//#endregion
-//#region src/compat/outgoing-jsonld.ts
-const logger$3 = getLogger([
-	"fedify",
-	"compat",
-	"outgoing-jsonld"
-]);
-const ATTACHMENT_FIELDS = /* @__PURE__ */ new Set(["attachment", "https://www.w3.org/ns/activitystreams#attachment"]);
-const AS_CONTEXT_URL = "https://www.w3.org/ns/activitystreams";
-const KNOWN_SAFE_CONTEXT_URLS = getKnownSafeContextUrls();
-const MAX_TRAVERSAL_DEPTH = 64;
-function isJsonLdListObject(value) {
-	return typeof value === "object" && value != null && Object.hasOwn(value, "@list");
-}
-function isJsonLdValueObject(value) {
-	return typeof value === "object" && value != null && Object.hasOwn(value, "@value");
-}
-function* getContextObjects(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (Array.isArray(value)) {
-		if (seen.has(value)) return;
-		seen.add(value);
-		for (const item of value) yield* getContextObjects(item, seen);
-		return;
-	}
-	if (typeof value === "object" && value != null) {
-		if (seen.has(value)) return;
-		seen.add(value);
-		const record = value;
-		yield record;
-		for (const definition of Object.values(record)) {
-			if (typeof definition !== "object" || definition == null) continue;
-			const nestedContext = definition["@context"];
-			if (nestedContext == null) continue;
-			yield* getContextObjects(nestedContext, seen);
-		}
-	}
-}
-function isActivityStreamsAttachmentTerm(value) {
-	return typeof value === "object" && value != null && value["@id"] === "as:attachment" && value["@type"] === "@id";
-}
-/** @internal */
-function isPreloadedContextAttachmentSafe(document) {
-	if (typeof document !== "object" || document == null) return true;
-	const context = document["@context"];
-	for (const contextObject of getContextObjects(context)) {
-		if (!Object.hasOwn(contextObject, "attachment")) continue;
-		if (isActivityStreamsAttachmentTerm(contextObject.attachment)) continue;
-		return false;
-	}
-	return true;
-}
-function getKnownSafeContextUrls() {
-	const urls = /* @__PURE__ */ new Set();
-	for (const [url, document] of Object.entries(preloadedContexts)) if (isPreloadedContextAttachmentSafe(document)) urls.add(url);
-	else logger$3.warn("Preloaded JSON-LD context {contextUrl} redefines the `attachment` term incompatibly; attachment array normalization will require canonicalization for documents using it.", { contextUrl: url });
-	return urls;
-}
-/**
-* Wraps scalar ActivityStreams attachment properties in arrays.
-*/
-function wrapScalarAttachments(jsonLd, preserveSecured, depth = 0) {
-	if (depth >= MAX_TRAVERSAL_DEPTH) return jsonLd;
-	if (preserveSecured && depth > 0 && isSelfContainedSecuredDocument(jsonLd)) return jsonLd;
-	if (Array.isArray(jsonLd)) {
-		let normalized = null;
-		for (let i = 0; i < jsonLd.length; i++) {
-			const item = jsonLd[i];
-			const next = wrapScalarAttachments(item, preserveSecured, depth + 1);
-			if (normalized == null && next !== item) normalized = jsonLd.slice(0, i);
-			if (normalized != null) normalized[i] = next;
-		}
-		return normalized ?? jsonLd;
-	}
-	if (typeof jsonLd !== "object" || jsonLd == null) return jsonLd;
-	const record = jsonLd;
-	const keys = Object.keys(record);
-	let normalized = null;
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		const value = record[key];
-		const next = key === "@context" || key === "@value" && isJsonLdValueObject(jsonLd) ? value : wrapScalarAttachments(value, preserveSecured, depth + 1);
-		const output = ATTACHMENT_FIELDS.has(key) && next != null && !Array.isArray(next) && !isJsonLdListObject(next) ? [next] : next;
-		if (normalized == null && output !== value) {
-			const cloned = Object.create(null);
-			for (let j = 0; j < i; j++) {
-				const previousKey = keys[j];
-				cloned[previousKey] = record[previousKey];
-			}
-			normalized = cloned;
-		}
-		if (normalized != null) normalized[key] = output;
-	}
-	return normalized ?? jsonLd;
-}
-function hasNestedContext(value, depth = 0) {
-	if (depth >= MAX_TRAVERSAL_DEPTH) return true;
-	if (Array.isArray(value)) return value.some((item) => hasNestedContext(item, depth + 1));
-	if (typeof value !== "object" || value == null) return false;
-	const record = value;
-	for (const key of Object.keys(record)) {
-		if (key === "@context") return true;
-		if (key === "@value" && isJsonLdValueObject(value)) continue;
-		if (hasNestedContext(record[key], depth + 1)) return true;
-	}
-	return false;
-}
-function exceedsTraversalDepth(value, depth = 0) {
-	if (depth >= MAX_TRAVERSAL_DEPTH) return true;
-	if (Array.isArray(value)) return value.some((item) => exceedsTraversalDepth(item, depth + 1));
-	if (typeof value !== "object" || value == null) return false;
-	const record = value;
-	for (const key of Object.keys(record)) {
-		if (key === "@context" || key === "@value" && isJsonLdValueObject(value)) continue;
-		if (exceedsTraversalDepth(record[key], depth + 1)) return true;
-	}
-	return false;
-}
-function hasKnownSafeContext(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return false;
-	const record = jsonLd;
-	if (!Object.hasOwn(record, "@context")) return false;
-	const context = record["@context"];
-	const entries = typeof context === "string" ? [context] : Array.isArray(context) ? context : null;
-	if (entries == null || entries.length < 1) return false;
-	let hasActivityStreamsContext = false;
-	for (const entry of entries) {
-		if (typeof entry !== "string") return false;
-		if (!KNOWN_SAFE_CONTEXT_URLS.has(entry)) return false;
-		if (entry === AS_CONTEXT_URL) hasActivityStreamsContext = true;
-	}
-	if (!hasActivityStreamsContext) return false;
-	for (const key of Object.keys(record)) {
-		if (key === "@context") continue;
-		if (hasNestedContext(record[key])) return false;
-	}
-	return true;
-}
-function getLogSafeJsonLdMetadata(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return {};
-	const record = jsonLd;
-	const context = record["@context"];
-	return {
-		id: typeof record.id === "string" ? record.id : typeof record["@id"] === "string" ? record["@id"] : void 0,
-		type: typeof record.type === "string" ? record.type : typeof record["@type"] === "string" ? record["@type"] : void 0,
-		context: typeof context === "string" ? context : Array.isArray(context) ? context.filter((entry) => typeof entry === "string").slice(0, 4) : context == null ? void 0 : "[inline context]"
-	};
-}
-/**
-* Ensures ActivityStreams attachment properties are represented as arrays
-* when doing so preserves the JSON-LD semantics.
-*
-* JSON-LD compaction collapses single-item arrays into scalar values by
-* default.  Some ActivityPub implementations, Pixelfed among them, parse
-* `attachment` as a plain JSON array rather than a JSON-LD property and reject
-* otherwise valid objects whose single attachment is emitted as a scalar.
-*
-* When no `contextLoader` is supplied, the helper falls back to a restricted
-* loader that resolves only Fedify's preloaded JSON-LD contexts and rejects
-* every other URL without network access.  Documents with custom, inline, or
-* otherwise uncached contexts should pass a real `contextLoader` if they need
-* the semantic-preservation check to succeed; otherwise canonicalization
-* failures leave the original document unchanged.
-*/
-async function normalizeAttachmentArrays(jsonLd, contextLoader, options = {}) {
-	const normalized = wrapScalarAttachments(jsonLd, options.preserveNestedSecuredDocuments ?? false);
-	if (normalized === jsonLd) return jsonLd;
-	if (exceedsTraversalDepth(jsonLd)) {
-		logger$3.debug("Skipping attachment array normalization because the JSON-LD document exceeds the safe traversal depth; leaving it unchanged.");
-		return jsonLd;
-	}
-	if (hasKnownSafeContext(jsonLd)) return normalized;
-	const loader = contextLoader ?? preloadedOnlyDocumentLoader;
-	try {
-		const [before, after] = await Promise.all([jsonld.canonize(jsonLd, {
-			format: "application/n-quads",
-			documentLoader: loader
-		}), jsonld.canonize(normalized, {
-			format: "application/n-quads",
-			documentLoader: loader
-		})]);
-		if (before === after) return normalized;
-		logger$3.warn("Wrapping scalar attachment values in arrays would change the canonical form of the JSON-LD document; leaving it unchanged.  This usually means the active JSON-LD context redefines the `attachment` term.  Document: {id}; type: {type}; context: {context}.", getLogSafeJsonLdMetadata(jsonLd));
-	} catch (error) {
-		logger$3.debug("Failed to verify attachment array normalization equivalence via JSON-LD canonicalization; leaving the JSON-LD document unchanged.\n{error}", { error });
-	}
-	return jsonLd;
-}
-/**
-* Applies Fedify's internal JSON-LD wire-format interoperability workarounds
-* to locally generated outgoing activities before they are signed, enqueued,
-* or sent.
-*/
-async function normalizeOutgoingActivityJsonLd(jsonLd, contextLoader, options = {}) {
-	jsonLd = await normalizePublicAudience(jsonLd, contextLoader, options);
-	return await normalizeAttachmentArrays(jsonLd, contextLoader, options);
-}
-//#endregion
-//#region src/sig/ld.ts
-const logger$2 = getLogger([
-	"fedify",
-	"sig",
-	"ld"
-]);
-const localContext = [
-	"https://w3id.org/identity/v1",
-	"https://www.w3.org/ns/activitystreams",
-	"https://w3id.org/security/v1",
-	"https://w3id.org/security/data-integrity/v1"
-];
-const localContextUrls = new Set(localContext);
-const builtInContextLoader = getDocumentLoader();
-const disallowedJsonLdKeywords = /* @__PURE__ */ new Set([
-	"@graph",
-	"@included",
-	"@reverse"
-]);
-/** @internal */
-var UnsafeJsonLdError = class extends TypeError {
-	keyword;
-	constructor(keyword) {
-		super(`Unsupported JSON-LD keyword: ${keyword}.`);
-		this.keyword = keyword;
-		this.name = "UnsafeJsonLdError";
-	}
-};
-/** @internal */
-var InvalidContextReferenceError = class extends TypeError {
-	reference;
-	constructor(reference) {
-		super(`Invalid JSON-LD context reference: ${reference}.`);
-		this.reference = reference;
-		this.name = "InvalidContextReferenceError";
-	}
-};
-function createLoadingRemoteContextFailedError(reference, cause) {
-	const message = cause instanceof Error ? cause.message : String(cause);
-	const error = /* @__PURE__ */ new Error(`Dereferencing a URL did not result in a valid JSON-LD context: ${reference}. ${message}`);
-	error.name = "jsonld.InvalidUrl";
-	error.details = {
-		code: "loading remote context failed",
-		url: reference
-	};
-	error.cause = cause;
-	return error;
-}
-/** @internal */
-function isClearlyMalformedContextReference(reference) {
-	for (const char of reference) {
-		const code = char.charCodeAt(0);
-		if (code <= 32 || code === 127) return true;
-	}
-	if (/^[A-Za-z][A-Za-z0-9+.-]*:/.test(reference) && !URL.canParse(reference)) return true;
-	for (let i = 0; i < reference.length; i++) {
-		if (reference[i] !== "%") continue;
-		if (i + 2 >= reference.length || !/[0-9A-Fa-f]/.test(reference[i + 1]) || !/[0-9A-Fa-f]/.test(reference[i + 2])) return true;
-		i += 2;
-	}
-	if (reference.startsWith("./") || reference.startsWith("../") || reference.startsWith("/") || reference.startsWith("//")) {
-		for (const char of reference) if ("[]<>\"\\^`{|}".includes(char)) return true;
-	}
-	return false;
-}
-function cloneRemoteDocument(remoteDocument) {
-	return structuredClone(remoteDocument);
-}
-function createMemoizedDocumentLoader(documentLoader) {
-	const cache = /* @__PURE__ */ new Map();
-	return async (url, options) => {
-		const cacheKey = URL.canParse(url) ? new URL(url).href : url;
-		let remoteDocument = cache.get(cacheKey);
-		if (remoteDocument == null) {
-			remoteDocument = Promise.resolve(documentLoader(url, options)).then(cloneRemoteDocument);
-			remoteDocument.catch(() => {
-				if (cache.get(cacheKey) === remoteDocument) cache.delete(cacheKey);
-			});
-			cache.set(cacheKey, remoteDocument);
-		}
-		return cloneRemoteDocument(await remoteDocument);
-	};
-}
-/** @internal */
-function wrapContextLoaderForJsonLd(contextLoader) {
-	const loader = contextLoader ?? builtInContextLoader;
-	return async (url, options) => {
-		try {
-			return await loader(url, options);
-		} catch (error) {
-			if (!isInvalidUrlTypeError(error)) throw error;
-			if (isClearlyMalformedContextReference(url)) throw new InvalidContextReferenceError(url);
-			throw createLoadingRemoteContextFailedError(url, error);
-		}
-	};
-}
-/** @internal */
-function getNormalizationContextLoader(contextLoader) {
-	const loader = wrapContextLoaderForJsonLd(contextLoader);
-	return createMemoizedDocumentLoader(async (url, options) => {
-		if (URL.canParse(url)) {
-			const normalizedUrl = new URL(url).href;
-			if (localContextUrls.has(normalizedUrl)) return await builtInContextLoader(normalizedUrl, options);
-		}
-		return await loader(url, options);
-	});
-}
-/** @internal */
-async function compactJsonLd(jsonLd, contextLoader) {
-	const hasLds = typeof jsonLd === "object" && jsonLd != null && "signature" in jsonLd;
-	const signature = hasLds ? jsonLd.signature : void 0;
-	const normalizationContextLoader = getNormalizationContextLoader(contextLoader);
-	const document = hasLds ? detachSignature(jsonLd) : jsonLd;
-	await assertNoGraphBeforeCompaction(document, normalizationContextLoader);
-	const compacted = await jsonld.compact(document, localContext, { documentLoader: normalizationContextLoader });
-	if (hasLds && typeof compacted === "object" && compacted != null) compacted.signature = signature;
-	assertSafeJsonLd(compacted);
-	return compacted;
-}
-function createInvalidRemoteContextError(reference) {
-	const error = /* @__PURE__ */ new Error(`Dereferencing a URL did not result in a JSON object. The response was valid JSON, but it was not a JSON object. URL: "${reference}".`);
-	error.name = "jsonld.InvalidUrl";
-	error.details = {
-		code: "invalid remote context",
-		url: reference
-	};
-	return error;
-}
-function getRemoteContext(remoteDocument, reference) {
-	const { contextUrl, documentUrl } = remoteDocument;
-	let { document } = remoteDocument;
-	if (typeof document === "string") document = JSON.parse(document);
-	if (typeof document !== "object" || document == null || Array.isArray(document)) throw createInvalidRemoteContextError(reference);
-	let context = "@context" in document ? document["@context"] : {};
-	if (contextUrl != null) context = Array.isArray(context) ? [...context, contextUrl] : [context, contextUrl];
-	return {
-		context,
-		baseUrl: documentUrl ?? reference
-	};
-}
-function createGraphAliasContextState() {
-	return {
-		graphTerms: /* @__PURE__ */ new Set(),
-		jsonTerms: /* @__PURE__ */ new Set(),
-		propertyContexts: /* @__PURE__ */ new Map(),
-		termTargets: /* @__PURE__ */ new Map()
-	};
-}
-function cloneGraphAliasContextState(state) {
-	return {
-		graphTerms: new Set(state.graphTerms),
-		jsonTerms: new Set(state.jsonTerms),
-		propertyContexts: new Map(state.propertyContexts),
-		termTargets: new Map(state.termTargets)
-	};
-}
-function resolveContextTarget(target, state) {
-	if (target === "@graph") return target;
-	const mapped = state.termTargets.get(target);
-	if (mapped == null) return target;
-	return mapped;
-}
-function getDirectContextTarget(definition) {
-	if (definition === null) return null;
-	if (typeof definition === "string") return definition;
-	if (typeof definition === "object" && definition != null && "@id" in definition) {
-		const id = definition["@id"];
-		if (id === null) return null;
-		if (typeof id === "string") return id;
-	}
-}
-function isJsonTypedDefinition(definition) {
-	return typeof definition === "object" && definition != null && "@type" in definition && definition["@type"] === "@json";
-}
-function resolveLocalContextTarget(target, state, localTargets, seen = /* @__PURE__ */ new Set()) {
-	if (target === "@graph") return target;
-	if (seen.has(target)) return target;
-	seen.add(target);
-	if (localTargets.has(target)) {
-		const localTarget = localTargets.get(target);
-		return localTarget == null ? target : resolveLocalContextTarget(localTarget, state, localTargets, seen);
-	}
-	return resolveContextTarget(target, state);
-}
-function refreshGraphAliases(state) {
-	state.graphTerms.clear();
-	for (const [term, target] of state.termTargets) if (target === "@graph") state.graphTerms.add(term);
-}
-function normalizeContextReference(reference, baseUrl) {
-	if (baseUrl != null) return new URL(reference, baseUrl).href;
-	return URL.canParse(reference) ? new URL(reference).href : reference;
-}
-/** @internal */
-function isInvalidUrlTypeError(error) {
-	const code = error.code;
-	return error instanceof TypeError && (code === "ERR_INVALID_URL" || /^Invalid URL(?::|$)/.test(error.message) || / cannot be parsed as a URL\.?$/.test(error.message));
-}
-async function applyGraphAliasContext(state, context, documentLoader, remoteContextCache, baseUrl = null, processingContexts = /* @__PURE__ */ new Set()) {
-	if (context === null) return createGraphAliasContextState();
-	let nextState = cloneGraphAliasContextState(state);
-	if (Array.isArray(context)) {
-		for (const item of context) nextState = await applyGraphAliasContext(nextState, item, documentLoader, remoteContextCache, baseUrl, processingContexts);
-		return nextState;
-	}
-	if (typeof context === "string") {
-		const reference = normalizeContextReference(context, baseUrl);
-		const cacheKey = `${baseUrl ?? ""}\n${reference}`;
-		if (processingContexts.has(cacheKey)) return nextState;
-		processingContexts.add(cacheKey);
-		try {
-			let remoteContext = remoteContextCache.get(cacheKey);
-			if (remoteContext == null) {
-				remoteContext = (async () => {
-					try {
-						return getRemoteContext(await documentLoader(reference), reference);
-					} catch (error) {
-						if (reference === context && isInvalidUrlTypeError(error) && isClearlyMalformedContextReference(context)) throw new InvalidContextReferenceError(context);
-						throw error;
-					}
-				})();
-				remoteContextCache.set(cacheKey, remoteContext);
-			}
-			const loadedRemoteContext = await remoteContext;
-			return await applyGraphAliasContext(nextState, loadedRemoteContext.context, documentLoader, remoteContextCache, loadedRemoteContext.baseUrl, processingContexts);
-		} finally {
-			processingContexts.delete(cacheKey);
-		}
-	}
-	if (typeof context === "object" && context != null) {
-		if ("@import" in context && typeof context["@import"] === "string") nextState = await applyGraphAliasContext(nextState, context["@import"], documentLoader, remoteContextCache, baseUrl, processingContexts);
-		const localTargets = /* @__PURE__ */ new Map();
-		for (const [term, definition] of globalThis.Object.entries(context)) {
-			if (term.startsWith("@")) continue;
-			const target = getDirectContextTarget(definition);
-			if (target == null) localTargets.set(term, null);
-			else if (typeof target === "string") localTargets.set(term, target);
-			else localTargets.delete(term);
-		}
-		for (const [term, definition] of globalThis.Object.entries(context)) {
-			if (term.startsWith("@")) continue;
-			if (localTargets.has(term)) {
-				const directTarget = localTargets.get(term);
-				if (directTarget == null) nextState.termTargets.set(term, null);
-				else nextState.termTargets.set(term, resolveLocalContextTarget(directTarget, nextState, localTargets));
-			} else nextState.termTargets.delete(term);
-			if (typeof definition === "object" && definition != null && "@context" in definition) nextState.propertyContexts.set(term, {
-				context: definition["@context"],
-				baseUrl
-			});
-			else nextState.propertyContexts.delete(term);
-			if (isJsonTypedDefinition(definition)) nextState.jsonTerms.add(term);
-			else nextState.jsonTerms.delete(term);
-		}
-		refreshGraphAliases(nextState);
-	}
-	return nextState;
-}
-async function assertNoGraphBeforeCompaction(jsonLd, documentLoader, inheritedState = createGraphAliasContextState(), propertyContext, remoteContextCache = /* @__PURE__ */ new Map()) {
-	if (Array.isArray(jsonLd)) {
-		for (const item of jsonLd) await assertNoGraphBeforeCompaction(item, documentLoader, inheritedState, propertyContext, remoteContextCache);
-		return;
-	}
-	if (typeof jsonLd !== "object" || jsonLd == null) return;
-	const jsonLiteralWrapper = isJsonLiteralWrapper(jsonLd);
-	let state = inheritedState;
-	if (propertyContext !== void 0) state = await applyGraphAliasContext(state, propertyContext.context, documentLoader, remoteContextCache, propertyContext.baseUrl);
-	if ("@context" in jsonLd) state = await applyGraphAliasContext(state, jsonLd["@context"], documentLoader, remoteContextCache);
-	for (const [key, value] of globalThis.Object.entries(jsonLd)) {
-		if (key === "@context") continue;
-		if (jsonLiteralWrapper && key === "@value") continue;
-		if (key === "@graph" || state.graphTerms.has(key)) throw new UnsafeJsonLdError("@graph");
-		if (state.jsonTerms.has(key)) continue;
-		await assertNoGraphBeforeCompaction(value, documentLoader, state, state.propertyContexts.get(key), remoteContextCache);
-	}
-}
-function isJsonLiteralWrapper(value) {
-	return "@value" in value && (value["@type"] === "@json" || value.type === "@json");
-}
-/** @internal */
-function assertSafeJsonLd(jsonLd) {
-	if (Array.isArray(jsonLd)) for (const item of jsonLd) assertSafeJsonLd(item);
-	else if (typeof jsonLd === "object" && jsonLd != null) {
-		const jsonLiteralWrapper = isJsonLiteralWrapper(jsonLd);
-		for (const [key, value] of globalThis.Object.entries(jsonLd)) {
-			if (disallowedJsonLdKeywords.has(key)) throw new UnsafeJsonLdError(key);
-			if (jsonLiteralWrapper && key === "@value") continue;
-			assertSafeJsonLd(value);
-		}
-	}
-}
-/**
-* Attaches a LD signature to the given JSON-LD document.
-* @param jsonLd The JSON-LD document to attach the signature to.  It is not
-*               modified.
-* @param signature The signature to attach.
-* @returns The JSON-LD document with the attached signature.
-* @throws {TypeError} If the input document is not a valid JSON-LD document.
-* @since 1.0.0
-*/
-function attachSignature(jsonLd, signature) {
-	if (typeof jsonLd !== "object" || jsonLd == null) throw new TypeError("Failed to attach signature; invalid JSON-LD document.");
-	return {
-		...jsonLd,
-		signature
-	};
-}
-/**
-* Creates a LD signature for the given JSON-LD document.
-* @param jsonLd The JSON-LD document to sign.
-* @param privateKey The private key to sign the document.
-* @param keyId The ID of the public key that corresponds to the private key.
-* @param options Additional options for creating the signature.
-*                See also {@link CreateSignatureOptions}.
-* @return The created signature.
-* @throws {TypeError} If the private key is invalid or unsupported.
-* @since 1.0.0
-*/
-async function createSignature(jsonLd, privateKey, keyId, { contextLoader, created } = {}) {
-	validateCryptoKey(privateKey, "private");
-	if (privateKey.algorithm.name !== "RSASSA-PKCS1-v1_5") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
-	const options = {
-		"@context": "https://w3id.org/identity/v1",
-		creator: keyId.href,
-		created: created?.toString() ?? (/* @__PURE__ */ new Date()).toISOString()
-	};
-	const message = await hashJsonLd(options, contextLoader) + await hashJsonLd(jsonLd, contextLoader);
-	const messageBytes = new TextEncoder().encode(message);
-	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", privateKey, messageBytes);
-	return {
-		...options,
-		type: "RsaSignature2017",
-		signatureValue: encodeBase64(signature)
-	};
-}
-/**
-* Signs the given JSON-LD document with the private key and returns the signed
-* JSON-LD document.
-* @param jsonLd The JSON-LD document to sign.
-* @param privateKey The private key to sign the document.
-* @param keyId The key ID to use in the signature.  It will be used by the
-*              verifier to fetch the corresponding public key.
-* @param options Additional options for signing the document.
-*                See also {@link SignJsonLdOptions}.
-* @returns The signed JSON-LD document.
-* @throws {TypeError} If the private key is invalid or unsupported.
-* @since 1.0.0
-*/
-async function signJsonLd(jsonLd, privateKey, keyId, options) {
-	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.sign", { attributes: { "ld_signatures.key_id": keyId.href } }, async (span) => {
-		try {
-			const signature = await createSignature(jsonLd, privateKey, keyId, options);
-			if (span.isRecording()) {
-				span.setAttribute("ld_signatures.type", signature.type);
-				span.setAttribute("ld_signatures.signature", encodeHex(decodeBase64(signature.signatureValue)));
-			}
-			return attachSignature(jsonLd, signature);
-		} catch (error) {
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	});
-}
-/**
-* Checks if the given JSON-LD document has a Linked Data Signature-like
-* object, without restricting it to a single suite-specific shape.
-* @param jsonLd The JSON-LD document to check.
-* @returns `true` if the document has a signature-like object; `false`
-*          otherwise.
-* @since 2.2.0
-*/
-function hasSignatureLike(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return false;
-	const signature = jsonLd.signature;
-	const hasReference = (value) => {
-		if (typeof value === "string") return true;
-		if (Array.isArray(value)) return value.some(hasReference);
-		return typeof value === "object" && value != null && ("id" in value && typeof value.id === "string" || "@id" in value && typeof value["@id"] === "string");
-	};
-	const hasSignatureObject = (value) => {
-		if (typeof value !== "object" || value == null) return false;
-		const signatureRecord = value;
-		return (typeof signatureRecord.type === "string" || Array.isArray(signatureRecord.type) && signatureRecord.type.some((item) => typeof item === "string")) && (hasReference(signatureRecord.creator) || hasReference(signatureRecord.verificationMethod)) && (typeof signatureRecord.signatureValue === "string" || typeof signatureRecord.jws === "string");
-	};
-	return Array.isArray(signature) ? signature.some(hasSignatureObject) : hasSignatureObject(signature);
-}
-/**
-* Checks if the given JSON-LD document has a Linked Data Signature.
-* @param jsonLd The JSON-LD document to check.
-* @returns `true` if the document has a signature; `false` otherwise.
-* @since 1.0.0
-*/
-function hasSignature(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return false;
-	if ("signature" in jsonLd) {
-		const signature = jsonLd.signature;
-		if (typeof signature !== "object" || signature == null) return false;
-		return "type" in signature && signature.type === "RsaSignature2017" && "creator" in signature && typeof signature.creator === "string" && "created" in signature && typeof signature.created === "string" && "signatureValue" in signature && typeof signature.signatureValue === "string";
-	}
-	return false;
-}
-/**
-* Detaches Linked Data Signatures from the given JSON-LD document.
-* @param jsonLd The JSON-LD document to modify.
-* @returns The modified JSON-LD document.  If the input document does not
-*          contain a signature, the original document is returned.
-* @since 1.0.0
-*/
-function detachSignature(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return jsonLd;
-	const doc = { ...jsonLd };
-	delete doc.signature;
-	return doc;
-}
-/**
-* Verifies Linked Data Signatures of the given JSON-LD document.
-*
-* This is a low-level utility that only checks the cryptographic signature
-* and (optionally) the cached key.  It does not run the JSON-LD parsing,
-* attribution, and owner checks that a complete inbound LD verification
-* needs.  For incoming activities, prefer {@link verifyJsonLd}, which is
-* the public verification entry point and the one that emits the
-* `activitypub.signature.verification.duration` metric for the LD path.
-* `verifySignature` itself only emits
-* `activitypub.signature.key_fetch.duration`, since the rest of the work
-* that the verification-duration metric is meant to cover happens in
-* `verifyJsonLd`.
-* @param jsonLd The JSON-LD document to verify.
-* @param options Options for verifying the signature.
-* @returns The public key that signed the document or `null` if the signature
-*          is invalid or the key is not found.
-* @since 1.0.0
-*/
-async function verifySignature(jsonLd, options = {}) {
-	if (!hasSignature(jsonLd)) return null;
-	const sig = jsonLd.signature;
-	let signature;
-	try {
-		signature = decodeBase64(sig.signatureValue);
-	} catch (error) {
-		logger$2.debug("Failed to verify; invalid base64 signatureValue: {signatureValue}", {
-			...sig,
-			error
-		});
-		return null;
-	}
-	const { key, cached } = await measureSignatureKeyFetch(options.meterProvider, "linked_data", () => fetchKey(new URL(sig.creator), CryptographicKey, options));
-	if (key == null) return null;
-	const sigOpts = {
-		...sig,
-		"@context": "https://w3id.org/identity/v1"
-	};
-	delete sigOpts.type;
-	delete sigOpts.id;
-	delete sigOpts.signatureValue;
-	let sigOptsHash;
-	try {
-		sigOptsHash = await hashJsonLd(sigOpts, options.contextLoader);
-	} catch (error) {
-		logger$2.warn("Failed to verify; failed to hash the signature options: {signatureOptions}\n{error}", {
-			signatureOptions: sigOpts,
-			error
-		});
-		return null;
-	}
-	const document = { ...jsonLd };
-	delete document.signature;
-	let docHash;
-	try {
-		docHash = await hashJsonLd(document, options.contextLoader);
-	} catch (error) {
-		logger$2.warn("Failed to verify; failed to hash the document: {document}\n{error}", {
-			document,
-			error
-		});
-		return null;
-	}
-	const encoder = new TextEncoder();
-	const message = sigOptsHash + docHash;
-	const messageBytes = encoder.encode(message);
-	if (await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes)) return key;
-	if (cached) {
-		logger$2.debug("Failed to verify with the cached key {keyId}; signature {signatureValue} is invalid.  Retrying with the freshly fetched key...", {
-			keyId: sig.creator,
-			...sig
-		});
-		const { key } = await measureSignatureKeyFetch(options.meterProvider, "linked_data", () => fetchKey(new URL(sig.creator), CryptographicKey, {
-			...options,
-			keyCache: {
-				get: () => Promise.resolve(void 0),
-				set: async (keyId, key) => await options.keyCache?.set(keyId, key)
-			}
-		}));
-		if (key == null) return null;
-		return await crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, signature.slice(), messageBytes) ? key : null;
-	}
-	logger$2.debug("Failed to verify with the fetched key {keyId}; signature {signatureValue} is invalid.  Check if the key is correct or if the signed message is correct.  The message to sign is:\n{message}", {
-		keyId: sig.creator,
-		...sig,
-		message
-	});
-	return null;
-}
-/**
-* Known Linked Data Signature `type` values, used to keep
-* `ld_signatures.type` on a bounded set of spec-defined string values.
-* Fedify only signs and verifies `RsaSignature2017`; other values come in
-* only from external documents and are dropped from the metric attribute to
-* avoid attacker-controlled cardinality.
-*/
-const LD_KNOWN_SIGNATURE_TYPES = /* @__PURE__ */ new Set(["RsaSignature2017"]);
-/**
-* Reports only whether a `signature` key is present on the document, with
-* no shape check on its value.  This is intentionally looser than
-* {@link hasSignature} (which validates a full `RsaSignature2017` shape)
-* and {@link hasSignatureLike} (which structurally accepts several known
-* suites): `verifyJsonLd` needs to tell a document with a malformed or
-* unsupported signature payload (classified as `rejected`) apart from a
-* truly unsigned document (classified as `missing`), and only this
-* presence-only check captures both cases.
-*/
-function hasLdSignatureProperty(jsonLd) {
-	return typeof jsonLd === "object" && jsonLd != null && "signature" in jsonLd;
-}
-function getLdSignatureObject(jsonLd) {
-	if (!hasLdSignatureProperty(jsonLd)) return void 0;
-	const { signature } = jsonLd;
-	if (typeof signature !== "object" || signature == null || Array.isArray(signature)) return;
-	return signature;
-}
-/**
-* Verify the authenticity of the given JSON-LD document using Linked Data
-* Signatures.  If the document is signed, this function verifies the signature
-* and checks if the document is attributed to the owner of the public key.
-* If the document is not signed, this function returns `false`.
-* @param jsonLd The JSON-LD document to verify.
-* @param options Options for verifying the document.
-* @returns `true` if the document is authentic; `false` otherwise.
-*/
-async function verifyJsonLd(jsonLd, options = {}) {
-	return await verifyJsonLdInternal(jsonLd, options, true);
-}
-/** @internal */
-async function verifyCompactJsonLd(jsonLd, options = {}) {
-	return await verifyJsonLdInternal(jsonLd, options, false);
-}
-async function verifyJsonLdInternal(jsonLd, options, compact) {
-	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.verify", async (span) => {
-		const start = performance.now();
-		let verified = false;
-		let threw = false;
-		let signatureType;
-		try {
-			const verificationOptions = hasSignature(jsonLd) ? {
-				...options,
-				contextLoader: getNormalizationContextLoader(options.contextLoader)
-			} : options;
-			const compacted = compact ? hasSignature(jsonLd) ? await compactJsonLd(jsonLd, options.contextLoader) : jsonLd : jsonLd;
-			const object = await Object$1.fromJsonLd(compacted, verificationOptions);
-			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
-			span.setAttribute("activitypub.object.type", getTypeId(object).href);
-			const sig = getLdSignatureObject(jsonLd);
-			if (sig != null) {
-				if (typeof sig.creator === "string") span.setAttribute("ld_signatures.key_id", sig.creator);
-				if (typeof sig.signatureValue === "string") span.setAttribute("ld_signatures.signature", sig.signatureValue);
-				if (typeof sig.type === "string") {
-					span.setAttribute("ld_signatures.type", sig.type);
-					if (LD_KNOWN_SIGNATURE_TYPES.has(sig.type)) signatureType = sig.type;
-				}
-			}
-			const attributions = new Set(object.attributionIds.map((uri) => uri.href));
-			if (object instanceof Activity) for (const uri of object.actorIds) attributions.add(uri.href);
-			const key = await verifySignature(compacted, verificationOptions);
-			if (key == null) return false;
-			if (key.ownerId == null) {
-				logger$2.debug("Key {keyId} has no owner.", { keyId: key.id?.href });
-				return false;
-			}
-			attributions.delete(key.ownerId.href);
-			if (attributions.size > 0) {
-				logger$2.debug("Some attributions are not authenticated by the Linked Data Signatures: {attributions}.", { attributions: [...attributions] });
-				return false;
-			}
-			verified = true;
-			return true;
-		} catch (error) {
-			threw = true;
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			const classified = threw ? "error" : verified ? "verified" : hasLdSignatureProperty(jsonLd) ? "rejected" : "missing";
-			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "linked_data", classified, { ldType: signatureType });
-			span.end();
-		}
-	});
-}
-async function hashJsonLd(jsonLd, contextLoader) {
-	const canon = await jsonld.canonize(jsonLd, {
-		format: "application/n-quads",
-		documentLoader: contextLoader ?? getDocumentLoader()
-	});
-	const encoder = new TextEncoder();
-	return encodeHex(await crypto.subtle.digest("SHA-256", encoder.encode(canon)));
-}
-//#endregion
-//#region src/sig/proof.ts
-/**
-* Known Object Integrity Proof `cryptosuite` values, used to keep
-* `object_integrity_proofs.cryptosuite` on a bounded set of spec-defined
-* string values.  Fedify currently signs and verifies only
-* `eddsa-jcs-2022`; other values come in only from external proofs and are
-* dropped from the metric attribute to avoid attacker-controlled
-* cardinality.
-*/
-const OIP_KNOWN_CRYPTOSUITES = /* @__PURE__ */ new Set(["eddsa-jcs-2022"]);
-const logger$1 = getLogger([
-	"fedify",
-	"sig",
-	"proof"
-]);
-const SECURITY_NAMESPACE = "https://w3id.org/security#";
-const SECURITY_PROOF = `${SECURITY_NAMESPACE}proof`;
-const SECURITY_PROOF_VALUE = `${SECURITY_NAMESPACE}proofValue`;
-const DATA_INTEGRITY_PROOF = `${SECURITY_NAMESPACE}DataIntegrityProof`;
-const SECURITY_VERIFICATION_METHOD = `${SECURITY_NAMESPACE}verificationMethod`;
-const SECURITY_EXPIRATION = `${SECURITY_NAMESPACE}expiration`;
-const SECURITY_DOMAIN = `${SECURITY_NAMESPACE}domain`;
-const SECURITY_CHALLENGE = `${SECURITY_NAMESPACE}challenge`;
-const SECURITY_NONCE = `${SECURITY_NAMESPACE}nonce`;
-const SECURITY_PREVIOUS_PROOF = `${SECURITY_NAMESPACE}previousProof`;
-/**
-* Checks if the given JSON-LD document has a DataIntegrityProof-like object,
-* without fully deserializing it into vocabulary classes.
-* @param jsonLd The JSON-LD document to check.
-* @returns `true` if the document has a proof-like object; `false` otherwise.
-* @since 2.2.0
-*/
-function hasProofLike(jsonLd) {
-	if (typeof jsonLd !== "object" || jsonLd == null) return false;
-	const record = jsonLd;
-	const proof = record.proof ?? record["https://w3id.org/security#proof"];
-	const getField = (source, compact, expanded) => source[compact] ?? source[expanded];
-	const isReference = (value) => {
-		if (typeof value === "string") return true;
-		if (Array.isArray(value)) return value.some(isReference);
-		return typeof value === "object" && value != null && ("id" in value && typeof value.id === "string" || "@id" in value && typeof value["@id"] === "string" || "@value" in value && typeof value["@value"] === "string");
-	};
-	const hasType = (value) => {
-		if (typeof value === "string") return value === "DataIntegrityProof" || value === "https://w3id.org/security#DataIntegrityProof";
-		if (Array.isArray(value)) return value.some(hasType);
-		return false;
-	};
-	const isProofLike = (value) => {
-		if (typeof value !== "object" || value == null) return false;
-		const proofRecord = value;
-		return hasType(proofRecord.type ?? proofRecord["@type"]) && isReference(getField(proofRecord, "verificationMethod", "https://w3id.org/security#verificationMethod")) && isReference(getField(proofRecord, "proofPurpose", "https://w3id.org/security#proofPurpose")) && isReference(getField(proofRecord, "proofValue", "https://w3id.org/security#proofValue"));
-	};
-	return Array.isArray(proof) ? proof.some(isProofLike) : isProofLike(proof);
-}
-function isJsonMap(value) {
-	return typeof value === "object" && value != null && !Array.isArray(value);
-}
-/**
-* Assembles the secured JSON document from the bytes that were just signed.
-*
-* The document is not re-derived from the vocabulary object: it is
-* `compactMsg`, the value whose JCS form was hashed, with the serialized
-* proof added.  Every part of it is then checked against the digests and the
-* signature that {@link createProofInternal} produced, so a document that is
-* returned verifies under the map-local compound-proof profile by
-* construction.  Anything that does not check out yields `null`, and the
-* caller simply does not retain a representation.
-*/
-async function captureSecuredDocument(proof, compactMsg, msgCanon, proofCanon, proofValue, contextLoader) {
-	if (!isJsonMap(compactMsg)) return null;
-	const documentContext = compactMsg["@context"];
-	if (documentContext == null) return null;
-	if (globalThis.Object.hasOwn(compactMsg, "proof")) return null;
-	try {
-		const proofJson = await proof.toJsonLd({
-			format: "compact",
-			contextLoader,
-			context: documentContext
-		});
-		if (!isJsonMap(proofJson)) return null;
-		const { proofValue: serializedProofValue, ...proofConfiguration } = proofJson;
-		if (serializedProofValue !== proofValue) return null;
-		if (serialize(proofConfiguration) !== proofCanon) return null;
-		const securedDocument = {
-			...structuredClone(compactMsg),
-			proof: structuredClone(proofJson)
-		};
-		const { proof: _embeddedProof, ...unsecuredDocument } = securedDocument;
-		if (serialize(unsecuredDocument) !== msgCanon) return null;
-		if (!isPlainJsonTree(securedDocument)) return null;
-		return securedDocument;
-	} catch (error) {
-		logger$1.debug("Failed to capture the secured JSON document for a created proof; the signed object will not preserve its representation when it is embedded in another object.\n{error}", { error });
-		return null;
-	}
-}
-async function createProofInternal(object, privateKey, keyId, { contextLoader, context, created } = {}, capture = false) {
-	validateCryptoKey(privateKey, "private");
-	if (privateKey.algorithm.name !== "Ed25519") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
-	let compactMsg = await object.clone({ proofs: [] }).toJsonLd({
-		format: "compact",
-		contextLoader,
-		context
-	});
-	compactMsg = await normalizeOutgoingActivityJsonLd(compactMsg, contextLoader, { preserveNestedSecuredDocuments: true });
-	const msgCanon = serialize(compactMsg);
-	const encoder = new TextEncoder();
-	const msgBytes = encoder.encode(msgCanon);
-	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
-	created ??= Temporal.Now.instant();
-	const proofCanon = serialize({
-		"@context": compactMsg["@context"],
-		type: "DataIntegrityProof",
-		cryptosuite: "eddsa-jcs-2022",
-		verificationMethod: keyId.href,
-		proofPurpose: "assertionMethod",
-		created: created.toString()
-	});
-	const proofBytes = encoder.encode(proofCanon);
-	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
-	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
-	digest.set(new Uint8Array(proofDigest), 0);
-	digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
-	const sig = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, digest));
-	const proof = new DataIntegrityProof({
-		cryptosuite: "eddsa-jcs-2022",
-		verificationMethod: keyId,
-		proofPurpose: "assertionMethod",
-		created,
-		proofValue: sig
-	});
-	return {
-		proof,
-		securedDocument: capture ? await captureSecuredDocument(proof, compactMsg, msgCanon, proofCanon, new TextDecoder().decode(encodeMultibase("base58btc", sig)), contextLoader) : null
-	};
-}
-/**
-* Creates a proof for the given object.
-* @param object The object to create a proof for.
-* @param privateKey The private key to sign the proof with.
-* @param keyId The key ID to use in the proof. It will be used by the verifier.
-* @param options Additional options.  See also {@link CreateProofOptions}.
-* @returns The created proof.
-* @throws {TypeError} If the private key is invalid or unsupported.
-* @since 0.10.0
-*/
-async function createProof(object, privateKey, keyId, options = {}) {
-	const { proof } = await createProofInternal(object, privateKey, keyId, options);
-	return proof;
-}
-/**
-* Signs the given object with the private key and returns the signed object.
-* @param object The object to create a proof for.
-* @param privateKey The private key to sign the proof with.
-* @param keyId The key ID to use in the proof. It will be used by the verifier.
-* @param options Additional options.  See also {@link SignObjectOptions}.
-* @returns The signed object.
-* @throws {TypeError} If the private key is invalid or unsupported.
-* @since 0.10.0
-*/
-async function signObject(object, privateKey, keyId, options = {}) {
-	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": getTypeId(object).href } }, async (span) => {
-		try {
-			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
-			const existingProofs = [];
-			for await (const proof of object.getProofs(options)) existingProofs.push(proof);
-			const { proof, securedDocument } = await createProofInternal(object, privateKey, keyId, options, existingProofs.length < 1);
-			if (span.isRecording()) {
-				if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
-				if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
-				if (proof.proofValue != null) span.setAttribute("object_integrity_proofs.signature", encodeHex(proof.proofValue));
-			}
-			const signed = object.clone({ proofs: [...existingProofs, proof] });
-			if (securedDocument != null) retainSignedRepresentation(signed, securedDocument);
-			else if (existingProofs.length > 0) logger$1.debug("The object {objectId} already had {proofCount} proof(s), so its signed representation is not retained for embedding; the map-local compound-proof profile accepts exactly one direct proof per map.", {
-				objectId: object.id?.href,
-				proofCount: existingProofs.length
-			});
-			return signed;
-		} catch (error) {
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	});
-}
-/**
-* Verifies the given proof for the object.
-* @param jsonLd The JSON-LD object to verify the proof for.  Its proof
-*               properties are excluded from the message, but matching proof
-*               occurrences are used to authenticate the received proof
-*               configuration.
-* @param proof The proof to verify.
-* @param options Additional options.  See also {@link VerifyProofOptions}.
-* @returns The public key that was used to sign the proof, or `null` if the
-*          proof is invalid.
-* @since 0.10.0
-* @since 2.4.0 Matching proof configurations are authenticated.
-*/
-async function verifyProof(jsonLd, proof, options = {}) {
-	return await verifyProofWithMessageDigestCache(jsonLd, proof, options);
-}
-/**
-* Verifies the one direct literal proof on a map-local secured document.
-*
-* Unlike {@link verifyProof}, this removes only the literal `proof` member
-* from the message digest.  JSON-LD aliases remain part of the signed input,
-* and the document's received `@context` is not replaced by the proof
-* configuration context.
-*
-* @internal
-*/
-async function verifyMapLocalProof(jsonLd, options = {}) {
-	if (!isJsonLdNode(jsonLd) || !globalThis.Object.hasOwn(jsonLd, "proof") || !isJsonLdNode(jsonLd.proof)) return null;
-	const proofContextLoader = getNormalizationContextLoader(preloadedOnlyDocumentLoader);
-	try {
-		const [candidate] = await parseRawProofCandidates(jsonLd, [jsonLd.proof], options, proofContextLoader);
-		if (candidate.proof == null) return null;
-		return await verifyProofWithMessageDigestCache(jsonLd, candidate.proof, options, {
-			proofContextLoader,
-			proofPropertyMode: "literal"
-		}, candidate);
-	} catch {
-		return null;
-	}
-}
-async function verifyProofWithMessageDigestCache(jsonLd, proof, options, messageDigestCache = {}, rawProofCandidate, keyIdBoundByCaller = false) {
-	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.verify", async (span) => {
-		const start = performance.now();
-		let verified = false;
-		let threw = false;
-		const cryptosuite = proof.cryptosuite != null && OIP_KNOWN_CRYPTOSUITES.has(proof.cryptosuite) ? proof.cryptosuite : void 0;
-		if (span.isRecording()) {
-			if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
-			if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
-			if (proof.proofValue != null) span.setAttribute("object_integrity_proofs.signature", encodeHex(proof.proofValue));
-		}
-		try {
-			const key = await verifyProofInternal(jsonLd, proof, options, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
-			if (key == null) span.setStatus({ code: SpanStatusCode.ERROR });
-			else verified = true;
-			return key;
-		} catch (error) {
-			threw = true;
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			const classified = threw ? "error" : verified ? "verified" : "rejected";
-			getFederationMetrics(options.meterProvider).recordSignatureVerificationDuration(getDurationMs(start), "object_integrity", classified, { cryptosuite });
-			span.end();
-		}
-	});
-}
-function expandContextPropertyIri(activeContext, key) {
-	const termId = jsonld.getContextValue(activeContext, key, "@id");
-	if (termId != null) return termId;
-	const colon = key.indexOf(":");
-	if (colon < 1) return key;
-	const prefix = key.substring(0, colon);
-	const suffix = key.substring(colon + 1);
-	if (prefix === "_" || suffix.startsWith("//")) return key;
-	const mapping = jsonld.getContextValue(activeContext, prefix);
-	if (typeof mapping === "object" && mapping != null && mapping._prefix === true && typeof mapping["@id"] === "string") return mapping["@id"] + suffix;
-	return key;
-}
-async function getJsonLdPropertyNames(jsonLd, propertyIri, defaults, documentLoader = preloadedOnlyDocumentLoader, inheritedContext, rejectOnContextError = false) {
-	const names = new Set(defaults);
-	const context = jsonLd["@context"] ?? inheritedContext;
-	if (context == null) return names;
-	try {
-		const options = { documentLoader };
-		let activeContext = await jsonld.processContext(null, null, options);
-		activeContext = await jsonld.processContext(activeContext, context, options);
-		const typeScopedContext = activeContext;
-		for (const key of globalThis.Object.keys(jsonLd).sort()) {
-			if (key !== "@type" && expandContextPropertyIri(activeContext, key) !== "@type") continue;
-			const value = jsonLd[key];
-			const types = Array.isArray(value) ? value.slice().sort() : [value];
-			for (const type of types) {
-				if (typeof type !== "string") continue;
-				const scopedContext = jsonld.getContextValue(typeScopedContext, type, "@context");
-				if (scopedContext != null) activeContext = await jsonld.processContext(activeContext, scopedContext, options);
-			}
-		}
-		for (const key of globalThis.Object.keys(jsonLd)) if (expandContextPropertyIri(activeContext, key) === propertyIri) names.add(key);
-	} catch {
-		if (rejectOnContextError) return null;
-	}
-	return names;
-}
-async function getProofPropertyNames(jsonLd, documentLoader = preloadedOnlyDocumentLoader) {
-	return await getJsonLdPropertyNames(jsonLd, SECURITY_PROOF, ["proof", SECURITY_PROOF], documentLoader) ?? /* @__PURE__ */ new Set(["proof", SECURITY_PROOF]);
-}
-async function createProofMessageDigests(jsonLd, proofContextLoader, context, proofPropertyMode = "jsonLd") {
-	const msg = { ...jsonLd };
-	if (proofPropertyMode === "literal") delete msg.proof;
-	else for (const property of await getProofPropertyNames(msg, proofContextLoader)) delete msg[property];
-	if (proofPropertyMode === "jsonLd" && context != null) msg["@context"] = structuredClone(context);
-	const encoder = new TextEncoder();
-	const digest = async (value) => {
-		const bytes = encoder.encode(serialize(value));
-		return await crypto.subtle.digest("SHA-256", bytes);
-	};
-	const onWire = await digest(msg);
-	let normalizedPromise;
-	return {
-		onWire,
-		normalized() {
-			normalizedPromise ??= (async () => {
-				const normalized = await normalizeOutgoingActivityJsonLd(msg, preloadedOnlyDocumentLoader);
-				return normalized === msg ? null : await digest(normalized);
-			})();
-			return normalizedPromise;
-		}
-	};
-}
-function contextValues(context) {
-	return Array.isArray(context) ? context : [context];
-}
-function equalJsonValues(left, right) {
-	try {
-		return serialize(left) === serialize(right);
-	} catch {
-		return false;
-	}
-}
-function contextStartsWith(documentContext, proofContext) {
-	if (documentContext == null) return false;
-	const documentValues = contextValues(documentContext);
-	const proofValues = contextValues(proofContext);
-	return proofValues.length <= documentValues.length && proofValues.every((value, index) => equalJsonValues(value, documentValues[index]));
-}
-function appendProofValues(values, value) {
-	if (Array.isArray(value)) for (const item of value) appendProofValues(values, item);
-	else if (isJsonLdNode(value) && Array.isArray(value["@graph"])) for (const item of value["@graph"]) appendProofValues(values, item);
-	else values.push(value);
-}
-async function getRawProofValues(jsonLd, documentLoader) {
-	const propertyNames = await getProofPropertyNames(jsonLd, documentLoader);
-	const values = [];
-	for (const [property, value] of globalThis.Object.entries(jsonLd)) if (propertyNames.has(property)) appendProofValues(values, value);
-	return values;
-}
-function sameBytes(left, right) {
-	if (left == null || right == null) return left === right;
-	return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function sameProof(left, right) {
-	return left.cryptosuite === right.cryptosuite && left.verificationMethodId?.href === right.verificationMethodId?.href && left.proofPurpose === right.proofPurpose && sameBytes(left.proofValue, right.proofValue) && left.created?.toString() === right.created?.toString();
-}
-function normalizeDocumentUrl(url) {
-	try {
-		return formatIri(parseIri(url));
-	} catch {
-		return URL.canParse(url) ? new URL(url).href : url;
-	}
-}
-function getRawProofReference(value) {
-	const node = Array.isArray(value) && value.length === 1 ? value[0] : value;
-	if (typeof node === "string") return normalizeDocumentUrl(node);
-	if (!isJsonLdNode(node)) return void 0;
-	const id = node["@id"] ?? node.id;
-	return typeof id === "string" ? normalizeDocumentUrl(id) : void 0;
-}
-async function parseRawProofCandidates(jsonLd, values, options, documentLoader) {
-	const candidates = [];
-	for (const value of values) {
-		let parsed = null;
-		if (isJsonLdNode(value)) {
-			const proofJsonLd = value["@context"] == null && jsonLd["@context"] != null ? {
-				"@context": jsonLd["@context"],
-				...value
-			} : value;
-			try {
-				parsed = await DataIntegrityProof.fromJsonLd(proofJsonLd, {
-					...options,
-					contextLoader: documentLoader
-				});
-			} catch {}
-		}
-		candidates.push({
-			value,
-			proof: parsed,
-			reference: getRawProofReference(value) ?? parsed?.id?.href
-		});
-	}
-	return candidates;
-}
-async function findRawProofCandidate(jsonLd, proof, options, documentLoader) {
-	const candidates = await parseRawProofCandidates(jsonLd, await getRawProofValues(jsonLd, documentLoader), options, documentLoader);
-	const matches = [];
-	for (const candidate of candidates) if (candidate.proof != null && sameProof(candidate.proof, proof)) matches.push(candidate);
-	if (matches.length < 1) return void 0;
-	const first = matches[0];
-	const configurations = await Promise.all(matches.map((candidate) => normalizeProofConfiguration(candidate.value, jsonLd["@context"], documentLoader)));
-	const firstConfiguration = configurations[0];
-	return firstConfiguration != null && configurations.every((configuration) => configuration != null && equalJsonValues(configuration.value, firstConfiguration.value)) ? first : null;
-}
-function takeRawProofCandidate(pool, proof) {
-	for (let index = 0; index < pool.candidates.length; index++) {
-		if (pool.used.has(index)) continue;
-		const candidate = pool.candidates[index];
-		if (candidate.proof != null && sameProof(candidate.proof, proof)) {
-			pool.used.add(index);
-			return candidate;
-		}
-	}
-}
-const STANDARD_COMPACT_PROOF_PROPERTIES = /* @__PURE__ */ new Set([
-	"@context",
-	"type",
-	"cryptosuite",
-	"verificationMethod",
-	"proofPurpose",
-	"proofValue",
-	"created"
-]);
-const STANDARD_EXPANDED_PROOF_PROPERTIES = /* @__PURE__ */ new Set([
-	"@context",
-	"@type",
-	`${SECURITY_NAMESPACE}cryptosuite`,
-	SECURITY_VERIFICATION_METHOD,
-	`${SECURITY_NAMESPACE}proofPurpose`,
-	`${SECURITY_NAMESPACE}proofValue`,
-	"http://purl.org/dc/terms/created"
-]);
-function hasAdditionalProofOptions(value) {
-	const node = Array.isArray(value) && value.length === 1 ? value[0] : value;
-	return isJsonLdNode(node) && globalThis.Object.keys(node).some((property) => !STANDARD_COMPACT_PROOF_PROPERTIES.has(property) && !STANDARD_EXPANDED_PROOF_PROPERTIES.has(property));
-}
-function isExpandedJsonLdNode(value) {
-	const properties = globalThis.Object.keys(value).filter((key) => !key.startsWith("@"));
-	return properties.length > 0 && properties.every((property) => URL.canParse(property));
-}
-async function normalizeProofConfiguration(rawProof, documentContext, documentLoader) {
-	let node = Array.isArray(rawProof) && rawProof.length === 1 ? rawProof[0] : rawProof;
-	if (!isJsonLdNode(node)) return null;
-	if (isExpandedJsonLdNode(node)) {
-		if (documentContext == null) return null;
-		node = await jsonld.compact(node, documentContext, { documentLoader });
-		if (!isJsonLdNode(node)) return null;
-	} else node = structuredClone(node);
-	const receivedContext = node["@context"];
-	if (receivedContext != null && !contextStartsWith(documentContext, receivedContext)) return null;
-	const context = receivedContext ?? documentContext;
-	if (context != null) node["@context"] = structuredClone(context);
-	const proofValueProperties = await getJsonLdPropertyNames(node, SECURITY_PROOF_VALUE, ["proofValue", SECURITY_PROOF_VALUE], documentLoader, context) ?? /* @__PURE__ */ new Set(["proofValue", SECURITY_PROOF_VALUE]);
-	for (const property of proofValueProperties) delete node[property];
-	return {
-		value: node,
-		context
-	};
-}
-async function createProofConfiguration(jsonLd, proof, options, documentLoader, rawProofCandidate) {
-	let rawProof;
-	if (rawProofCandidate == null) {
-		const match = await findRawProofCandidate(jsonLd, proof, options, documentLoader);
-		if (match === null) return null;
-		rawProof = match?.value;
-	} else rawProof = rawProofCandidate.value;
-	if (rawProof == null) {
-		const serializedProof = await proof.toJsonLd();
-		if (hasAdditionalProofOptions(serializedProof)) rawProof = serializedProof;
-	}
-	if (rawProof != null) return await normalizeProofConfiguration(rawProof, jsonLd["@context"], documentLoader);
-	const context = jsonLd["@context"];
-	return {
-		value: {
-			...context == null ? {} : { "@context": context },
-			type: "DataIntegrityProof",
-			cryptosuite: proof.cryptosuite,
-			verificationMethod: proof.verificationMethodId.href,
-			proofPurpose: proof.proofPurpose,
-			created: proof.created.toString()
-		},
-		context
-	};
-}
-const KNOWN_PROOF_CONFIGURATION_PROPERTIES = /* @__PURE__ */ new Set([
-	"@context",
-	"@id",
-	"@type",
-	"id",
-	"type",
-	"cryptosuite",
-	`${SECURITY_NAMESPACE}cryptosuite`,
-	"verificationMethod",
-	SECURITY_VERIFICATION_METHOD,
-	"proofPurpose",
-	`${SECURITY_NAMESPACE}proofPurpose`,
-	"created",
-	"http://purl.org/dc/terms/created",
-	"expires",
-	SECURITY_EXPIRATION,
-	"domain",
-	SECURITY_DOMAIN,
-	"challenge",
-	SECURITY_CHALLENGE,
-	"nonce",
-	SECURITY_NONCE,
-	"previousProof",
-	SECURITY_PREVIOUS_PROOF
-]);
-async function getProofOption(proofConfig, propertyIri, defaults, documentLoader) {
-	let names = await getJsonLdPropertyNames(proofConfig, propertyIri, defaults, documentLoader, proofConfig["@context"], true);
-	if (names == null) {
-		if (globalThis.Object.keys(proofConfig).some((property) => !KNOWN_PROOF_CONFIGURATION_PROPERTIES.has(property))) return null;
-		names = new Set(defaults);
-	}
-	const present = globalThis.Object.keys(proofConfig).filter((property) => names.has(property));
-	if (present.length > 1) return null;
-	return present.length < 1 ? { present: false } : {
-		present: true,
-		value: proofConfig[present[0]]
-	};
-}
-function parseStringSet(value) {
-	if (typeof value === "string") return /* @__PURE__ */ new Set([value]);
-	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) return null;
-	return new Set(value);
-}
-function equalStringSets(left, right) {
-	return left.size === right.size && [...left].every((value) => right.has(value));
-}
-async function hasValidProofOptions(proofConfig, options, documentLoader) {
-	const expires = await getProofOption(proofConfig, SECURITY_EXPIRATION, ["expires", SECURITY_EXPIRATION], documentLoader);
-	if (expires == null) return false;
-	if (expires.present) {
-		if (typeof expires.value !== "string") return false;
-		let expiration;
-		try {
-			expiration = Temporal.Instant.from(expires.value);
-		} catch {
-			return false;
-		}
-		if (Temporal.Instant.compare(Temporal.Now.instant(), expiration) >= 0) return false;
-	}
-	const domain = await getProofOption(proofConfig, SECURITY_DOMAIN, ["domain", SECURITY_DOMAIN], documentLoader);
-	if (domain == null) return false;
-	const proofDomains = domain.present ? parseStringSet(domain.value) : null;
-	if (domain.present && proofDomains == null) return false;
-	if (options.domain != null) {
-		const expectedDomains = parseStringSet(options.domain);
-		if (expectedDomains == null || proofDomains == null || !equalStringSets(proofDomains, expectedDomains)) return false;
-	}
-	const challenge = await getProofOption(proofConfig, SECURITY_CHALLENGE, ["challenge", SECURITY_CHALLENGE], documentLoader);
-	if (challenge == null || challenge.present && typeof challenge.value !== "string" || options.challenge != null && (!challenge.present || challenge.value !== options.challenge)) return false;
-	const nonce = await getProofOption(proofConfig, SECURITY_NONCE, ["nonce", SECURITY_NONCE], documentLoader);
-	if (nonce == null || nonce.present && typeof nonce.value !== "string") return false;
-	const previousProof = await getProofOption(proofConfig, SECURITY_PREVIOUS_PROOF, ["previousProof", SECURITY_PREVIOUS_PROOF], documentLoader);
-	if (previousProof == null || previousProof.present && typeof previousProof.value !== "string" && (!Array.isArray(previousProof.value) || previousProof.value.some((item) => typeof item !== "string"))) return false;
-	return true;
-}
-async function verifyProofInternal(jsonLd, proof, options, messageDigestCache, rawProofCandidate, keyIdBoundByCaller = false) {
-	if (!isJsonLdNode(jsonLd) || proof.cryptosuite !== "eddsa-jcs-2022" || proof.verificationMethodId == null || proof.proofPurpose !== "assertionMethod" || proof.proofValue == null || proof.created == null) return null;
-	const proofContextLoader = messageDigestCache.proofContextLoader ?? preloadedOnlyDocumentLoader;
-	const proofConfiguration = await createProofConfiguration(jsonLd, proof, options, proofContextLoader, rawProofCandidate);
-	if (proofConfiguration == null || !await hasValidProofOptions(proofConfiguration.value, options, proofContextLoader)) return null;
-	const publicKeyPromise = measureSignatureKeyFetch(options.meterProvider, "object_integrity", () => fetchKey(proof.verificationMethodId, Multikey, {
-		...options,
-		keyIdBoundByCaller
-	}));
-	const proofBytes = new TextEncoder().encode(serialize(proofConfiguration.value));
-	const proofDigest = await crypto.subtle.digest("SHA-256", proofBytes);
-	let fetchedKey;
-	try {
-		fetchedKey = await publicKeyPromise;
-	} catch (error) {
-		logger$1.debug("Failed to get the key (verificationMethod) for the proof:\n{proof}", {
-			proof,
-			keyId: proof.verificationMethodId.href,
-			error
-		});
-		return null;
-	}
-	const publicKey = fetchedKey.key;
-	if (publicKey == null) {
-		logger$1.debug("Failed to get the key (verificationMethod) for the proof:\n{proof}", {
-			proof,
-			keyId: proof.verificationMethodId.href
-		});
-		return null;
-	}
-	if (publicKey.publicKey.algorithm.name !== "Ed25519") {
-		if (fetchedKey.cached) {
-			logger$1.debug("The cached key (verificationMethod) for the proof is not a valid Ed25519 key:\n{keyId}; retrying with the freshly fetched key...", {
-				proof,
-				keyId: proof.verificationMethodId.href
-			});
-			return await verifyProofInternal(jsonLd, proof, {
-				...options,
-				keyCache: {
-					get: () => Promise.resolve(void 0),
-					set: async (keyId, key) => await options.keyCache?.set(keyId, key)
-				}
-			}, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
-		}
-		logger$1.debug("The fetched key (verificationMethod) for the proof is not a valid Ed25519 key:\n{keyId}", {
-			proof,
-			keyId: proof.verificationMethodId.href
-		});
-		return null;
-	}
-	const digest = new Uint8Array(proofDigest.byteLength + 32);
-	digest.set(new Uint8Array(proofDigest), 0);
-	const proofValue = proof.proofValue;
-	const verifyCandidate = async (msgDigest) => {
-		digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
-		return await crypto.subtle.verify("Ed25519", publicKey.publicKey, proofValue.slice(), digest);
-	};
-	const messageDigestKey = serialize(proofConfiguration.context ?? null);
-	const messageDigestValues = messageDigestCache.values ??= /* @__PURE__ */ new Map();
-	let messageDigestsPromise = messageDigestValues.get(messageDigestKey);
-	if (messageDigestsPromise == null) {
-		messageDigestsPromise = createProofMessageDigests(jsonLd, messageDigestCache.proofContextLoader, proofConfiguration.context, messageDigestCache.proofPropertyMode);
-		messageDigestValues.set(messageDigestKey, messageDigestsPromise);
-	}
-	const messageDigests = await messageDigestsPromise;
-	if (await verifyCandidate(messageDigests.onWire)) return publicKey;
-	if (messageDigestCache.proofPropertyMode !== "literal") {
-		const normalizedDigest = await messageDigests.normalized();
-		if (normalizedDigest != null && await verifyCandidate(normalizedDigest)) return publicKey;
-	}
-	if (fetchedKey.cached) {
-		logger$1.debug("Failed to verify the proof with the cached key {keyId}; retrying with the freshly fetched key...", {
-			keyId: proof.verificationMethodId.href,
-			proof
-		});
-		return await verifyProofInternal(jsonLd, proof, {
-			...options,
-			keyCache: {
-				get: () => Promise.resolve(void 0),
-				set: async (keyId, key) => await options.keyCache?.set(keyId, key)
-			}
-		}, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
-	}
-	logger$1.debug("Failed to verify the proof with the fetched key {keyId}:\n{proof}", {
-		keyId: proof.verificationMethodId.href,
-		proof
-	});
-	return null;
-}
-const AS_NAMESPACE = "https://www.w3.org/ns/activitystreams#";
-const FEP_2277_ACTOR_PROPERTIES = ["http://www.w3.org/ns/ldp#inbox", `${AS_NAMESPACE}outbox`];
-const FEP_2277_COLLECTION_PROPERTIES = [
-	"items",
-	"orderedItems",
-	"totalItems",
-	"partOf",
-	"first",
-	"last",
-	"next",
-	"prev",
-	"current"
-].map((property) => AS_NAMESPACE + property);
-const PORTABLE_OBJECT_ID_PATTERN = /^ap(?:\+ef61)?:\/\//i;
-const FUNCTIONAL_PROOF_PROPERTIES = [
-	`${SECURITY_NAMESPACE}cryptosuite`,
-	SECURITY_VERIFICATION_METHOD,
-	`${SECURITY_NAMESPACE}proofPurpose`,
-	`${SECURITY_NAMESPACE}proofValue`,
-	"http://purl.org/dc/terms/created"
-];
-function isJsonLdNode(value) {
-	return typeof value === "object" && value != null && !Array.isArray(value);
-}
-function hasValidPortableProofShape(proofValue) {
-	if (!isJsonLdNode(proofValue)) return false;
-	let proofNode = proofValue;
-	if ("@graph" in proofNode) {
-		const graph = proofNode["@graph"];
-		if (!Array.isArray(graph) || graph.length !== 1 || !isJsonLdNode(graph[0])) return false;
-		proofNode = graph[0];
-	}
-	const types = proofNode["@type"];
-	return Array.isArray(types) && types.length === 1 && types[0] === DATA_INTEGRITY_PROOF && FUNCTIONAL_PROOF_PROPERTIES.every((property) => {
-		const values = proofNode[property];
-		return Array.isArray(values) && values.length === 1 && !(isJsonLdNode(values[0]) && "@list" in values[0]);
-	});
-}
-function classifyFep2277CoreType(node) {
-	if (FEP_2277_ACTOR_PROPERTIES.every((property) => property in node)) return "actor";
-	if (`${SECURITY_NAMESPACE}publicKeyMultibase` in node) return "verificationMethod";
-	if (`${SECURITY_NAMESPACE}publicKeyPem` in node) return "publicKey";
-	if (`${AS_NAMESPACE}href` in node) return "link";
-	if (`${AS_NAMESPACE}actor` in node) return "activity";
-	if (FEP_2277_COLLECTION_PROPERTIES.some((property) => property in node)) return "collection";
-	return "object";
-}
-async function expandPortableObjectRoot(jsonLd, contextLoader) {
-	if (!isJsonLdNode(jsonLd)) throw new TypeError("Expected a single JSON-LD object.");
-	const loadedContexts = /* @__PURE__ */ new Map();
-	const loader = getNormalizationContextLoader(contextLoader);
-	const recordingLoader = async (url, options) => {
-		const remoteDocument = await loader(url, options);
-		const key = URL.canParse(url) ? new URL(url).href : url;
-		loadedContexts.set(key, structuredClone(remoteDocument));
-		return remoteDocument;
-	};
-	const expanded = await jsonld.expand(jsonLd, {
-		documentLoader: recordingLoader,
-		keepFreeFloatingNodes: true
-	});
-	if (expanded.length !== 1 || !isJsonLdNode(expanded[0])) throw new TypeError("Expected a single JSON-LD object.");
-	return {
-		root: expanded[0],
-		proofContextLoader: async (url, options) => {
-			const key = URL.canParse(url) ? new URL(url).href : url;
-			const remoteDocument = loadedContexts.get(key);
-			if (remoteDocument != null) return structuredClone(remoteDocument);
-			return await preloadedOnlyDocumentLoader(url, options);
-		}
-	};
-}
-async function preparePortableObjectProof(jsonLd, options) {
-	if (isJsonLdNode(jsonLd) && typeof jsonLd["@id"] === "string" && !PORTABLE_OBJECT_ID_PATTERN.test(jsonLd["@id"])) return {
-		prepared: false,
-		result: {
-			verified: false,
-			reason: { type: "notPortableObject" }
-		}
-	};
-	const { root, proofContextLoader } = await expandPortableObjectRoot(jsonLd, options.contextLoader);
-	const id = root["@id"];
-	if (typeof id !== "string" || !PORTABLE_OBJECT_ID_PATTERN.test(id)) return {
-		prepared: false,
-		result: {
-			verified: false,
-			reason: { type: "notPortableObject" }
-		}
-	};
-	const objectId = parseIri(id);
-	getFe34Origin(objectId);
-	const objectType = classifyFep2277CoreType(root);
-	if (objectType === "verificationMethod" || objectType === "publicKey" || objectType === "link") return {
-		prepared: false,
-		result: {
-			verified: false,
-			reason: {
-				type: "unsupportedObjectType",
-				objectType
-			}
-		}
-	};
-	const proofValues = root[SECURITY_PROOF];
-	if (proofValues == null || Array.isArray(proofValues) && proofValues.length < 1) return {
-		prepared: false,
-		root,
-		objectType,
-		result: objectType === "collection" ? {
-			verified: false,
-			reason: { type: "unsecuredCollection" }
-		} : {
-			verified: false,
-			reason: { type: "missingProof" }
-		}
-	};
-	if (!Array.isArray(proofValues)) return {
-		prepared: false,
-		result: {
-			verified: false,
-			reason: {
-				type: "invalidProof",
-				proofIndex: 0
-			}
-		}
-	};
-	const rawProofValues = isJsonLdNode(jsonLd) ? await getRawProofValues(jsonLd, proofContextLoader) : [];
-	const proofs = [];
-	for (let proofIndex = 0; proofIndex < proofValues.length; proofIndex++) {
-		const proofValue = proofValues[proofIndex];
-		if (!hasValidPortableProofShape(proofValue)) return {
-			prepared: false,
-			result: {
-				verified: false,
-				reason: {
-					type: "invalidProof",
-					proofIndex
-				}
-			}
-		};
-		let proof;
-		try {
-			proof = await DataIntegrityProof.fromJsonLd(proofValue, options);
-		} catch {
-			return {
-				prepared: false,
-				result: {
-					verified: false,
-					reason: {
-						type: "invalidProof",
-						proofIndex
-					}
-				}
-			};
-		}
-		proofs.push(proof);
-	}
-	for (let proofIndex = 0; proofIndex < proofs.length; proofIndex++) {
-		const verificationMethod = proofs[proofIndex].verificationMethodId;
-		if (verificationMethod == null) return {
-			prepared: false,
-			result: {
-				verified: false,
-				reason: {
-					type: "invalidProof",
-					proofIndex
-				}
-			}
-		};
-		if (verificationMethod.protocol !== "did:") return {
-			prepared: false,
-			result: {
-				verified: false,
-				reason: {
-					type: "unsupportedVerificationMethod",
-					proofIndex,
-					verificationMethod
-				}
-			}
-		};
-		try {
-			getFe34Origin(verificationMethod);
-		} catch (error) {
-			if (!(error instanceof TypeError)) throw error;
-			return {
-				prepared: false,
-				result: {
-					verified: false,
-					reason: {
-						type: "unsupportedVerificationMethod",
-						proofIndex,
-						verificationMethod
-					}
-				}
-			};
-		}
-		if (!haveSameFe34Origin(objectId, verificationMethod)) return {
-			prepared: false,
-			result: {
-				verified: false,
-				reason: {
-					type: "verificationMethodMismatch",
-					proofIndex,
-					objectId,
-					verificationMethod
-				}
-			}
-		};
-	}
-	return {
-		prepared: true,
-		root,
-		objectType,
-		objectId,
-		proofs,
-		rawProofValues,
-		proofContextLoader
-	};
-}
-/**
-* Applies portable-object proof policy to one map-local cryptographic result.
-*
-* @internal
-*/
-async function verifyPortableObjectProofPolicy(jsonLd, key, options = {}) {
-	const policyOptions = {
-		...options,
-		contextLoader: preloadedOnlyDocumentLoader
-	};
-	const prepared = await preparePortableObjectProof(jsonLd, policyOptions);
-	if (!prepared.prepared) return prepared.result;
-	const policyProof = prepared.proofs[0];
-	const literalProof = isJsonLdNode(jsonLd) && isJsonLdNode(jsonLd.proof) ? (await parseRawProofCandidates(jsonLd, [jsonLd.proof], policyOptions, prepared.proofContextLoader))[0]?.proof : null;
-	const verificationMethod = policyProof?.verificationMethodId;
-	if (prepared.proofs.length !== 1 || key == null || policyProof == null || literalProof == null || !sameProof(policyProof, literalProof) || verificationMethod == null || key.id?.href !== verificationMethod.href) return {
-		verified: false,
-		reason: {
-			type: "invalidProof",
-			proofIndex: prepared.proofs.length > 1 ? 1 : 0
-		}
-	};
-	return {
-		verified: true,
-		keys: [key],
-		objectId: formatIri(prepared.objectId)
-	};
-}
-/**
-* Verifies the FEP-ef61 Object Integrity Proof policy for a portable object.
-*
-* This applies the FEP-2277 core-type classification to the top-level JSON-LD
-* node.  Portable actors, activities, and objects require proofs.  A portable
-* collection without a proof is reported separately so a caller can apply a
-* gateway trust policy.  Embedded portable objects are not traversed.
-*
-* Every proof must use a DID URL whose DID matches the portable object's
-* authority, and every proof must pass {@link verifyProof}.
-*
-* @param jsonLd The JSON-LD document to verify.
-* @param options Additional options.  See also
-*                {@link VerifyPortableObjectProofOptions}.
-* @returns The detailed portable proof-policy result.
-* @throws {TypeError} If the input is not a single JSON-LD object or has a
-*                     malformed portable ID.
-* @since 2.4.0
-*/
-async function verifyPortableObjectProof(jsonLd, options = {}) {
-	return (await verifyPortableObjectProofWithRoot(jsonLd, options)).result;
-}
-/**
-* Same as {@link verifyPortableObjectProof}, but also returns the expanded
-* root node and its FEP-2277 core type, so that a caller can apply further
-* policy, such as the gateway trust policy for unsecured collections, to the
-* same interpretation of the document.
-* @internal
-*/
-async function verifyPortableObjectProofWithRoot(jsonLd, options = {}) {
-	const prepared = await preparePortableObjectProof(jsonLd, options);
-	if (!prepared.prepared) return {
-		result: prepared.result,
-		...prepared.root == null ? {} : { root: prepared.root },
-		...prepared.objectType == null ? {} : { objectType: prepared.objectType }
-	};
-	const { root, objectType } = prepared;
-	return {
-		result: await verifyPreparedPortableObjectProof(jsonLd, prepared, options),
-		root,
-		objectType
-	};
-}
-async function verifyPreparedPortableObjectProof(jsonLd, prepared, options) {
-	const { proofs, rawProofValues, proofContextLoader } = prepared;
-	const keys = [];
-	const rawProofCandidatePool = {
-		candidates: await parseRawProofCandidates(jsonLd, rawProofValues, options, proofContextLoader),
-		used: /* @__PURE__ */ new Set()
-	};
-	const messageDigestCache = { proofContextLoader };
-	for (let proofIndex = 0; proofIndex < proofs.length; proofIndex++) {
-		const rawProofCandidate = takeRawProofCandidate(rawProofCandidatePool, proofs[proofIndex]);
-		if (rawProofCandidate == null) return {
-			verified: false,
-			reason: {
-				type: "invalidProof",
-				proofIndex
-			}
-		};
-		const key = await verifyProofWithMessageDigestCache(jsonLd, proofs[proofIndex], options, messageDigestCache, rawProofCandidate, true);
-		if (key == null) return {
-			verified: false,
-			reason: {
-				type: "invalidProof",
-				proofIndex
-			}
-		};
-		keys.push(key);
-	}
-	return {
-		verified: true,
-		keys
-	};
-}
-/**
-* Verifies the given object.  It will verify all the proofs in the object,
-* and succeed only if all the proofs are valid and all attributions and
-* actors are authenticated by the proofs.
-* @template T The type of the object to verify.
-* @param cls The class of the object to verify.  It must be a subclass of
-*            the {@link Object}.
-* @param jsonLd The JSON-LD object to verify.  It's assumed that the object
-*               is a compacted JSON-LD representation of a `T` with `@context`.
-* @param options Additional options.  See also {@link VerifyObjectOptions}.
-* @returns The object if it's verified, or `null` if it's not.
-* @throws {TypeError} If the object is invalid or unsupported.
-* @since 0.10.0
-*/
-async function verifyObject(cls, jsonLd, options = {}) {
-	const logger = getLogger([
-		"fedify",
-		"sig",
-		"proof"
-	]);
-	const object = await cls.fromJsonLd(jsonLd, options);
-	const defaultDocumentLoader = getDocumentLoader();
-	const proofContextLoader = options.contextLoader ?? defaultDocumentLoader;
-	const attributions = new Set(object.attributionIds.map((uri) => uri.href));
-	if (object instanceof Activity) for (const uri of object.actorIds) attributions.add(uri.href);
-	const rawProofValues = isJsonLdNode(jsonLd) ? await getRawProofValues(jsonLd, proofContextLoader) : [];
-	const rawProofCandidates = isJsonLdNode(jsonLd) ? await parseRawProofCandidates(jsonLd, rawProofValues, options, proofContextLoader) : [];
-	const rawProofCandidatePool = {
-		candidates: rawProofCandidates,
-		used: /* @__PURE__ */ new Set()
-	};
-	const baseDocumentLoader = options.documentLoader ?? defaultDocumentLoader;
-	const hydratedCandidates = /* @__PURE__ */ new Set();
-	let loadedPortableProofs = 0;
-	let acceptedPortableProofs = 0;
-	const acceptPortableProofDocument = async () => {
-		acceptedPortableProofs++;
-		return { verified: true };
-	};
-	const proofDocumentLoader = async (url, loaderOptions) => {
-		const remoteDocument = await baseDocumentLoader(url, loaderOptions);
-		if (PORTABLE_OBJECT_ID_PATTERN.test(url)) loadedPortableProofs++;
-		const reference = normalizeDocumentUrl(url);
-		const candidateIndex = rawProofCandidates.findIndex((candidate, index) => !hydratedCandidates.has(index) && !rawProofCandidatePool.used.has(index) && candidate.reference === reference);
-		if (candidateIndex >= 0) {
-			hydratedCandidates.add(candidateIndex);
-			let parsed = null;
-			try {
-				parsed = await DataIntegrityProof.fromJsonLd(remoteDocument.document, {
-					documentLoader: baseDocumentLoader,
-					contextLoader: proofContextLoader,
-					tracerProvider: options.tracerProvider,
-					baseUrl: parseIri(remoteDocument.documentUrl)
-				});
-			} catch {}
-			rawProofCandidates[candidateIndex] = {
-				value: structuredClone(remoteDocument.document),
-				proof: parsed,
-				reference
-			};
-		}
-		return remoteDocument;
-	};
-	for await (const proof of object.getProofs({
-		...options,
-		documentLoader: proofDocumentLoader,
-		gateways: [],
-		verifyPortableObject: acceptPortableProofDocument
-	})) {
-		const rawProofCandidate = takeRawProofCandidate(rawProofCandidatePool, proof);
-		if (rawProofCandidate == null) return null;
-		const key = await verifyProofWithMessageDigestCache(jsonLd, proof, options, { proofContextLoader }, rawProofCandidate);
-		if (key === null) return null;
-		if (proof.verificationMethodId == null) return null;
-		if (key.controllerId == null) {
-			logger.debug("Key {keyId} does not have a controller.", { keyId: key.id?.href });
-			continue;
-		}
-		deleteAuthenticatedAttribution(attributions, key.controllerId, proof.verificationMethodId);
-	}
-	if (acceptedPortableProofs < loadedPortableProofs) {
-		logger.debug("Some portable proof references could not be dereferenced.");
-		return null;
-	}
-	if (attributions.size > 0) {
-		logger.debug("Some attributions are not authenticated by the proofs: {attributions}.", { attributions: [...attributions] });
-		return null;
-	}
-	return object;
-}
-function deleteAuthenticatedAttribution(attributions, controllerId, verificationMethodId) {
-	const controllerHasCryptographicOrigin = hasCryptographicOrigin(controllerId.href);
-	const verificationMethodMatchesController = controllerHasCryptographicOrigin && hasCryptographicOrigin(verificationMethodId.href) && haveSameFe34Origin(controllerId, verificationMethodId);
-	if (!controllerHasCryptographicOrigin || verificationMethodMatchesController) attributions.delete(controllerId.href);
-	if (!verificationMethodMatchesController) return;
-	for (const attribution of [...attributions]) if (hasCryptographicOrigin(attribution) && haveSameFe34Origin(controllerId, attribution)) attributions.delete(attribution);
-}
-function hasCryptographicOrigin(iri) {
-	return /^did:/i.test(iri) || /^ap(?:\+ef61)?:\/\//i.test(iri);
-}
-//#endregion
-//#region src/sig/owner.ts
-const logger = getLogger([
-	"fedify",
-	"sig",
-	"owner"
-]);
-/**
-* Checks if the actor of the given activity owns the specified key.
-*
-* Ownership is never taken from what the activity or the key say about
-* themselves, as both are written by whoever sent the activity.  It is
-* established from a document that the owner itself serves: either the key's
-* claimed owner links back to the key, or the actor the activity claims lists
-* the key as its own.
-*
-* @param activity The activity to check.
-* @param key The public key to check.
-* @param options Options for checking the key ownership.
-* @returns Whether the actor is the owner of the key.
-*/
-async function doesActorOwnKey(activity, key, options) {
-	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("activitypub.verify_key_ownership", {
-		kind: SpanKind.INTERNAL,
-		attributes: {
-			"activitypub.actor.id": activity.actorId?.href ?? "",
-			"activitypub.key.id": key.id?.href ?? ""
-		}
-	}, async (span) => {
-		try {
-			const actorId = activity.actorId;
-			if (actorId == null) {
-				span.setAttribute("activitypub.key_ownership.verified", false);
-				span.setAttribute("activitypub.key_ownership.method", "none");
-				return false;
-			}
-			if (key.ownerId != null) {
-				const owner = await verifyKeyOwnership(key, options);
-				if (owner?.id != null && owner.id.href === actorId.href) {
-					span.setAttribute("activitypub.key_ownership.verified", true);
-					span.setAttribute("activitypub.key_ownership.method", "key_owner");
-					return true;
-				}
-			}
-			const actor = await fetchActorDocument(actorId, options);
-			if (actor != null && await doesActorListKey(actor, key, options)) {
-				span.setAttribute("activitypub.key_ownership.verified", true);
-				span.setAttribute("activitypub.key_ownership.method", "actor_fetch");
-				return true;
-			}
-			logger.debug("The actor {actorId} does not own key {keyId}: neither the owner the key claims nor the actor's own document links the two to each other.", {
-				actorId: actorId.href,
-				keyId: key.id?.href
-			});
-			span.setAttribute("activitypub.key_ownership.verified", false);
-			span.setAttribute("activitypub.key_ownership.method", "actor_fetch");
-			return false;
-		} catch (error) {
-			span.recordException(error);
-			span.setStatus({
-				code: SpanStatusCode.ERROR,
-				message: String(error)
-			});
-			throw error;
-		} finally {
-			span.end();
-		}
-	});
-}
-/**
-* Determines whether the given actor's own document lists the given key among
-* its public keys.
-*
-* Keys are matched by id, which is what an actor document links to.  A key
-* document may leave its id implicit, though, and then there is no id for the
-* actor to link to; the key material itself is the only thing the two can
-* have in common, so that is what gets compared.
-*/
-async function doesActorListKey(actor, key, options) {
-	if (key.id != null) {
-		for (const publicKeyId of actor.publicKeyIds) if (publicKeyId.href === key.id.href) return true;
-		return false;
-	}
-	if (key.publicKey == null) return false;
-	const publicKeys = actor.getPublicKeys({
-		...options,
-		suppressError: true
-	});
-	for await (const publicKey of publicKeys) {
-		if (publicKey.publicKey == null) continue;
-		if (await isSamePublicKey(publicKey.publicKey, key.publicKey)) return true;
-	}
-	return false;
-}
-/**
-* Compares two public keys by their key material, ignoring the metadata that
-* surrounds it.
-*/
-async function isSamePublicKey(a, b) {
-	const [x, y] = await Promise.all([exportJwk(a), exportJwk(b)]);
-	return x.kty === y.kty && x.crv === y.crv && x.n === y.n && x.e === y.e && x.x === y.x && x.y === y.y;
-}
-/**
-* Gets the actor that owns the specified key.  Returns `null` if the key has no
-* known owner.
-*
-* The owner is only returned when the key and the owner link to each other:
-* a document that merely claims to own a key is not enough, as the claim and
-* the key can come from the same host.
-*
-* @param keyId The ID of the key to check, or the key itself.
-* @param options Options for getting the key owner.
-* @returns The actor that owns the key, or `null` if the key has no known
-*          owner.
-* @since 0.7.0
-*/
-async function getKeyOwner(keyId, options) {
-	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-	const documentLoader = options.documentLoader ?? getDocumentLoader();
-	const fetchOptions = {
-		documentLoader,
-		contextLoader: options.contextLoader ?? getDocumentLoader(),
-		tracerProvider
-	};
-	if (keyId instanceof CryptographicKey) return await verifyKeyOwnership(keyId, fetchOptions);
-	let keyDoc;
-	let documentUrl = keyId;
-	try {
-		const remoteDocument = await documentLoader(keyId.href);
-		keyDoc = remoteDocument.document;
-		documentUrl = new URL(remoteDocument.documentUrl ?? "", keyId);
-	} catch (_) {
-		return null;
-	}
-	let object;
-	try {
-		object = await Object$1.fromJsonLd(keyDoc, {
-			...fetchOptions,
-			baseUrl: documentUrl
-		});
-	} catch (e) {
-		if (!(e instanceof TypeError)) throw e;
-		try {
-			object = await CryptographicKey.fromJsonLd(keyDoc, fetchOptions);
-		} catch (e) {
-			if (e instanceof TypeError) return null;
-			throw e;
-		}
-	}
-	if (object instanceof CryptographicKey) {
-		if (object.id != null && object.id.href !== keyId.href) return null;
-		return await verifyKeyOwnership(object.id == null ? object.clone({ id: keyId }) : object, fetchOptions);
-	}
-	if (!isActor(object)) return null;
-	if (object.id == null || object.id.origin !== documentUrl.origin) {
-		logger.debug("The document served at {documentUrl} claims to be the actor {actorId}, which belongs to another origin; refusing to treat it as the owner of key {keyId}.", {
-			documentUrl: documentUrl.href,
-			actorId: object.id?.href,
-			keyId: keyId.href
-		});
-		return null;
-	}
-	for (const kid of object.publicKeyIds) if (kid.href === keyId.href) return object;
-	return null;
-}
-//#endregion
-export { signJsonLd as C, wrapContextLoaderForJsonLd as D, verifySignature as E, normalizeOutgoingActivityJsonLd as O, isInvalidUrlTypeError as S, verifyJsonLd as T, detachSignature as _, signObject as a, hasSignatureLike as b, verifyPortableObjectProof as c, verifyProof as d, InvalidContextReferenceError as f, createSignature as g, compactJsonLd as h, hasProofLike as i, verifyPortableObjectProofPolicy as l, attachSignature as m, getKeyOwner as n, verifyMapLocalProof as o, assertSafeJsonLd as p, createProof as r, verifyObject as s, doesActorOwnKey as t, verifyPortableObjectProofWithRoot as u, getNormalizationContextLoader as v, verifyCompactJsonLd as w, isClearlyMalformedContextReference as x, hasSignature as y };