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

package/dist/{http-BGShIsd6.cjs → http-DGk8XI38.cjs}

@@ -1,15 +1,21 @@
 const { URLPattern } = require("urlpattern-polyfill");
+const require_rolldown_runtime = require("./rolldown-runtime-Dmm3t92W.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab = require("@fedify/vocab");
 let _opentelemetry_api = require("@opentelemetry/api");
 let byte_encodings_hex = require("byte-encodings/hex");
 let _fedify_vocab_runtime = require("@fedify/vocab-runtime");
+let _fedify_vocab_runtime_jsonld = require("@fedify/vocab-runtime/jsonld");
+_fedify_vocab_runtime_jsonld = require_rolldown_runtime.__toESM(_fedify_vocab_runtime_jsonld, 1);
 let structured_field_values = require("structured-field-values");
+let _fedify_vocab_runtime_internal_signed_representation = require("@fedify/vocab-runtime/internal/signed-representation");
+let json_canon = require("json-canon");
+json_canon = require_rolldown_runtime.__toESM(json_canon, 1);
 let byte_encodings_base64 = require("byte-encodings/base64");
 let _opentelemetry_semantic_conventions = require("@opentelemetry/semantic-conventions");
 //#region deno.json
 var name = "@fedify/fedify";
-var version = "2.4.0-dev.2065+b09fdd33";
+var version = "2.4.0-dev.2073+2152dfc6";
 //#endregion
 //#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/chunks/root.js
 const NativeTemporal = globalThis.Temporal;
@@ -3556,7 +3562,7 @@ const Now = /*@__PURE__*/ Object.defineProperties({}, {
 		}
 	})
 });
-const Temporal$2 = /*@__PURE__*/ Object.defineProperties({}, {
+const Temporal$3 = /*@__PURE__*/ Object.defineProperties({}, {
 	...createStringTagDescriptors("Temporal"),
 	...createPropDescriptors({
 		PlainYearMonth,
@@ -3572,7 +3578,7 @@ const Temporal$2 = /*@__PURE__*/ Object.defineProperties({}, {
 });
 //#endregion
 //#region ../../node_modules/.pnpm/temporal-polyfill@1.0.1/node_modules/temporal-polyfill/index.js
-const Temporal$1 = NativeTemporal || Temporal$2;
+const Temporal$2 = NativeTemporal || Temporal$3;
 NativeTemporal && Date.prototype.toTemporalInstant;
 //#endregion
 //#region src/sig/accept.ts
@@ -3714,6 +3720,421 @@ function fulfillAcceptSignature(entry, localKeyId, localAlg) {
 	};
 }
 //#endregion
+//#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(_fedify_vocab_runtime.preloadedContexts, url)) return Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: _fedify_vocab_runtime.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 = (0, _logtape_logtape.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(_fedify_vocab_runtime.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 _fedify_vocab.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") ? _fedify_vocab.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([_fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
+			format: "application/n-quads",
+			documentLoader: loader
+		}), _fedify_vocab_runtime_jsonld.default.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 = (0, _logtape_logtape.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(_fedify_vocab_runtime.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([_fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
+			format: "application/n-quads",
+			documentLoader: loader
+		}), _fedify_vocab_runtime_jsonld.default.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/federation/metrics.ts
 var FederationMetrics = class {
 	deliverySent;
@@ -4524,6 +4945,99 @@ function getDurationMs(start) {
 	return Math.max(0, performance.now() - start);
 }
 //#endregion
+//#region src/sig/portable-key-id.ts
+const COMPATIBLE_KEY_ID_PATH_PATTERN = /^\/\.well-known\/apgateway\/did(?::|%3A)/i;
+/**
+* Checks whether the URL is an `ap:` or `ap+ef61:` URI.
+* @internal
+*/
+function isPortableUri(url) {
+	return url.protocol === "ap:" || url.protocol === "ap+ef61:";
+}
+/**
+* Checks whether an activity is performed by an FEP-ef61 portable actor,
+* i.e., any of its actors has an `ap:` or `ap+ef61:` ID.
+* @internal
+*/
+function hasPortableActor(activity) {
+	return activity.actorIds.some(isPortableUri);
+}
+/**
+* Checks whether a key ID looks like an [FEP-ef61] compatible identifier,
+* i.e., an HTTP(S) URL under a gateway's `/.well-known/apgateway/did:` path.
+* Such a key ID names a key that a gateway holds for a portable actor, so it
+* is resolved only as a gateway key, and never cached in a key cache.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* @internal
+*/
+function isCompatibleKeyId(keyId) {
+	return (keyId.protocol === "http:" || keyId.protocol === "https:") && COMPATIBLE_KEY_ID_PATH_PATTERN.test(keyId.pathname);
+}
+/**
+* Gets the canonical portable ID of an actor ID that is either an `ap:` or
+* `ap+ef61:` URI or a compatible identifier.
+* @returns The canonical portable ID, or `null` if the ID is neither, or is
+*          malformed.
+* @internal
+*/
+function getCanonicalPortableId(id) {
+	try {
+		if (isPortableUri(id)) return (0, _fedify_vocab_runtime.canonicalizePortableUri)((0, _fedify_vocab_runtime.formatIri)(id));
+		const portable = (0, _fedify_vocab_runtime.fromCompatibleEf61Id)(id);
+		if (portable == null) return null;
+		return (0, _fedify_vocab_runtime.canonicalizePortableUri)((0, _fedify_vocab_runtime.formatIri)(portable));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+/**
+* Builds the base of the key IDs of a gateway's keys for a portable actor:
+* the actor's compatible identifier on the gateway.
+* @param actorId The portable actor's ID, either an `ap:` or `ap+ef61:` URI
+*                or a compatible identifier.  It must not have a fragment.
+* @param gateway The gateway's origin, e.g., `https://example.com`.
+* @returns The compatible identifier without query and fragment.
+* @throws {TypeError} If the actor ID is not a portable ID, or has
+*                     a fragment.
+* @internal
+*/
+function getGatewayKeyBase(actorId, gateway) {
+	let portable;
+	if (isPortableUri(actorId)) portable = actorId;
+	else try {
+		portable = (0, _fedify_vocab_runtime.fromCompatibleEf61Id)(actorId);
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		portable = null;
+	}
+	if (portable == null) throw new TypeError(`The portable actor ID ${actorId.href} must be an ap: or ap+ef61: URI, or an FEP-ef61 compatible identifier.`);
+	if (portable.hash !== "") throw new TypeError(`The portable actor ID ${actorId.href} must not have a fragment.`);
+	const base = (0, _fedify_vocab_runtime.toCompatibleEf61Id)(portable, gateway);
+	base.search = "";
+	base.hash = "";
+	return base;
+}
+/**
+* Tells whether a parsed document at a compatible key ID is a portable actor,
+* which makes the key a gateway key that only
+* {@link verifyPortableGatewayKeyDocument} can vouch for.
+* @internal
+*/
+function isPortableActorDocument(object) {
+	return (0, _fedify_vocab.isActor)(object) && object.id != null && isPortableUri(object.id);
+}
+/**
+* Compares two public keys by their key material.
+* @internal
+*/
+async function isSamePublicKey(a, b) {
+	if (a.algorithm.name !== b.algorithm.name) return false;
+	const [x, y] = await Promise.all([crypto.subtle.exportKey("jwk", a), crypto.subtle.exportKey("jwk", 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;
+}
+//#endregion
 //#region src/sig/key.ts
 /**
 * Checks if the given key is valid and supported.  No-op if the key is valid,
@@ -4747,7 +5261,15 @@ async function withFetchKeySpan(keyId, tracerProvider, fetcher) {
 /**
 * Fetches a {@link CryptographicKey} or {@link Multikey} from the given URL.
 * If the given URL contains an {@link Actor} object, it tries to find
-* the corresponding key in the `publicKey` or `assertionMethod` property.
+* the corresponding key in the `publicKey` or `assertionMethod` property. *
+* Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
+* compatible identifiers that dereference to portable actor documents, are
+* not resolved by this function, as they only authenticate HTTP requests;
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys
+* whose IDs are compatible identifiers are never read from or written to
+* the key cache.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
 * @template T The type of the key to fetch.  Either {@link CryptographicKey}
 *              or {@link Multikey}.
 * @param keyId The URL of the key.
@@ -4764,7 +5286,15 @@ function fetchKey(keyId, cls, options = {}) {
 /**
 * Fetches a {@link CryptographicKey} or {@link Multikey} from the given URL,
 * preserving transport-level fetch failures for callers that need to inspect
-* why the key could not be loaded.
+* why the key could not be loaded. *
+* Gateway keys of [FEP-ef61] portable actors, i.e., keys whose IDs are
+* compatible identifiers that dereference to portable actor documents, are
+* not resolved by this function, as they only authenticate HTTP requests;
+* use `verifyRequest()` or `getKeyOwner()` for them instead.  Keys
+* whose IDs are compatible identifiers are never read from or written to
+* the key cache.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
 *
 * @template T The type of the key to fetch.  Either {@link CryptographicKey}
 *              or {@link Multikey}.
@@ -4915,7 +5445,7 @@ async function resolveDidKey(cacheKey, cls, keyCache, logger) {
 		cached: false
 	};
 }
-async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, { documentLoader, contextLoader, keyCache, tracerProvider, keyIdBoundByCaller }, logger) {
+async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, { documentLoader, contextLoader, keyCache, tracerProvider, keyIdBoundByCaller, portableGatewayKeyResolver }, logger) {
 	let object;
 	try {
 		object = await _fedify_vocab.Object.fromJsonLd(document, {
@@ -4944,6 +5474,33 @@ async function resolveFetchedKey(document, cacheKey, documentUrl, keyId, cls, {
 			throw e;
 		}
 	}
+	if (isCompatibleKeyId(cacheKey) && isPortableActorDocument(object)) {
+		if (portableGatewayKeyResolver == null || cls !== _fedify_vocab.CryptographicKey) {
+			logger.debug("Failed to verify; key {keyId} is a gateway key of the portable actor {actorId}, which is only accepted for HTTP Signatures.", {
+				keyId,
+				actorId: object.id?.href
+			});
+			return {
+				key: null,
+				cached: false
+			};
+		}
+		const resolution = await portableGatewayKeyResolver(document, object, cacheKey);
+		if (resolution.type !== "verified") {
+			logger.debug("Failed to verify; the portable actor {actorId} does not vouch for its gateway key {keyId}.", {
+				keyId,
+				actorId: object.id?.href
+			});
+			return {
+				key: null,
+				cached: false
+			};
+		}
+		return {
+			key: resolution.key,
+			cached: false
+		};
+	}
 	let key = null;
 	let ownerDocument = null;
 	if (object instanceof cls && (object.id == null || object.id.href === keyId)) key = object.id == null ? object.clone({ id: cacheKey }) : object;
@@ -5063,6 +5620,10 @@ async function fetchKeyWithResult(cacheKey, cls, options, onCachedUnavailable, o
 			"key"
 		]);
 		const keyId = cacheKey.href;
+		if (isCompatibleKeyId(cacheKey)) options = {
+			...options,
+			keyCache: void 0
+		};
 		const keyCache = options.keyCache;
 		const didKey = await resolveDidKey(cacheKey, cls, keyCache, logger);
 		if (didKey != null) {
@@ -5129,34 +5690,362 @@ async function fetchKeyInternal(keyId, cls, options = {}) {
 	});
 }
 //#endregion
-//#region src/sig/http.ts
-const Temporal = Temporal$1;
-const DEFAULT_MAX_REDIRECTION = 20;
-const DOUBLE_KNOCK_TRANSPORT_RETRY_DELAY_MS = 100;
+//#region src/sig/ld.ts
+const logger$2 = (0, _logtape_logtape.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 = (0, _fedify_vocab_runtime.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 _fedify_vocab_runtime_jsonld.default.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);
+		}
+	}
+}
 /**
-* Signs a request using the given private key.
-* @param request The request to sign.
-* @param privateKey The private key to use for signing.
-* @param keyId The key ID to use for the signature.  It will be used by the
-*              verifier.
-* @returns The signed request.
+* 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 signRequest(request, privateKey, keyId, options = {}) {
+async function createSignature(jsonLd, privateKey, keyId, { contextLoader, created } = {}) {
 	validateCryptoKey(privateKey, "private");
-	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("http_signatures.sign", async (span) => {
+	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: (0, byte_encodings_base64.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 ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("ld_signatures.sign", { attributes: { "ld_signatures.key_id": keyId.href } }, async (span) => {
 		try {
-			const spec = options.spec ?? "draft-cavage-http-signatures-12";
-			let signed;
-			if (spec === "rfc9421") signed = await signRequestRfc9421(request, privateKey, keyId, span, options.currentTime, options.body, options.rfc9421);
-			else signed = await signRequestDraft(request, privateKey, keyId, span, options.currentTime, options.body);
+			const signature = await createSignature(jsonLd, privateKey, keyId, options);
 			if (span.isRecording()) {
-				span.setAttribute(_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD, signed.method);
-				span.setAttribute(_opentelemetry_semantic_conventions.ATTR_URL_FULL, signed.url);
-				for (const [name, value] of signed.headers) span.setAttribute((0, _opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_HEADER)(name), value);
-				span.setAttribute("http_signatures.key_id", keyId.href);
+				span.setAttribute("ld_signatures.type", signature.type);
+				span.setAttribute("ld_signatures.signature", (0, byte_encodings_hex.encodeHex)((0, byte_encodings_base64.decodeBase64)(signature.signatureValue)));
 			}
-			return signed;
+			return attachSignature(jsonLd, signature);
 		} catch (error) {
 			span.setStatus({
 				code: _opentelemetry_api.SpanStatusCode.ERROR,
@@ -5168,23 +6057,1564 @@ async function signRequest(request, privateKey, keyId, options = {}) {
 		}
 	});
 }
-async function signRequestDraft(request, privateKey, keyId, span, currentTime, bodyBuffer) {
-	if (privateKey.algorithm.name !== "RSASSA-PKCS1-v1_5") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
-	const url = new URL(request.url);
-	const body = bodyBuffer !== void 0 ? bodyBuffer : request.method !== "GET" && request.method !== "HEAD" ? await request.clone().arrayBuffer() : null;
-	const headers = new Headers(request.headers);
-	if (!headers.has("Host")) headers.set("Host", url.host);
-	if (!headers.has("Digest") && body != null) {
-		const digest = await crypto.subtle.digest("SHA-256", body);
-		headers.set("Digest", `SHA-256=${(0, byte_encodings_base64.encodeBase64)(digest)}`);
-		if (span.isRecording()) span.setAttribute("http_signatures.digest.sha-256", (0, byte_encodings_hex.encodeHex)(digest));
+/**
+* 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";
 	}
-	if (!headers.has("Date")) headers.set("Date", currentTime == null ? (/* @__PURE__ */ new Date()).toUTCString() : new Date(currentTime.toString()).toUTCString());
-	const serialized = [["(request-target)", `${request.method.toLowerCase()} ${url.pathname}`], ...headers];
-	const headerNames = serialized.map(([name]) => name);
-	const message = serialized.map(([name, value]) => `${name}: ${value.trim()}`).join("\n");
-	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", privateKey, new TextEncoder().encode(message));
-	const sigHeader = `keyId="${keyId.href}",algorithm="rsa-sha256",headers="${headerNames.join(" ")}",signature="${(0, byte_encodings_base64.encodeBase64)(signature)}"`;
+	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 = (0, byte_encodings_base64.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), _fedify_vocab.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), _fedify_vocab.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 ?? _opentelemetry_api.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 _fedify_vocab.Object.fromJsonLd(compacted, verificationOptions);
+			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
+			span.setAttribute("activitypub.object.type", (0, _fedify_vocab.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 _fedify_vocab.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: _opentelemetry_api.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 _fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
+		format: "application/n-quads",
+		documentLoader: contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)()
+	});
+	const encoder = new TextEncoder();
+	return (0, byte_encodings_hex.encodeHex)(await crypto.subtle.digest("SHA-256", encoder.encode(canon)));
+}
+//#endregion
+//#region src/sig/proof.ts
+const Temporal$1 = Temporal$2;
+/**
+* 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 = (0, _logtape_logtape.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 ((0, json_canon.default)(proofConfiguration) !== proofCanon) return null;
+		const securedDocument = {
+			...structuredClone(compactMsg),
+			proof: structuredClone(proofJson)
+		};
+		const { proof: _embeddedProof, ...unsecuredDocument } = securedDocument;
+		if ((0, json_canon.default)(unsecuredDocument) !== msgCanon) return null;
+		if (!(0, _fedify_vocab_runtime_internal_signed_representation.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 = (0, json_canon.default)(compactMsg);
+	const encoder = new TextEncoder();
+	const msgBytes = encoder.encode(msgCanon);
+	const msgDigest = await crypto.subtle.digest("SHA-256", msgBytes);
+	created ??= Temporal$1.Now.instant();
+	const proofCanon = (0, json_canon.default)({
+		"@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 _fedify_vocab.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((0, _fedify_vocab_runtime.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 ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("object_integrity_proofs.sign", { attributes: { "activitypub.object.type": (0, _fedify_vocab.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", (0, byte_encodings_hex.encodeHex)(proof.proofValue));
+			}
+			const signed = object.clone({ proofs: [...existingProofs, proof] });
+			if (securedDocument != null) (0, _fedify_vocab_runtime_internal_signed_representation.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: _opentelemetry_api.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 ?? _opentelemetry_api.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", (0, byte_encodings_hex.encodeHex)(proof.proofValue));
+		}
+		try {
+			const key = await verifyProofInternal(jsonLd, proof, options, messageDigestCache, rawProofCandidate, keyIdBoundByCaller);
+			if (key == null) span.setStatus({ code: _opentelemetry_api.SpanStatusCode.ERROR });
+			else verified = true;
+			return key;
+		} catch (error) {
+			threw = true;
+			span.setStatus({
+				code: _opentelemetry_api.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 = _fedify_vocab_runtime_jsonld.default.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 = _fedify_vocab_runtime_jsonld.default.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 _fedify_vocab_runtime_jsonld.default.processContext(null, null, options);
+		activeContext = await _fedify_vocab_runtime_jsonld.default.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 = _fedify_vocab_runtime_jsonld.default.getContextValue(typeScopedContext, type, "@context");
+				if (scopedContext != null) activeContext = await _fedify_vocab_runtime_jsonld.default.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((0, json_canon.default)(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 (0, json_canon.default)(left) === (0, json_canon.default)(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 (0, _fedify_vocab_runtime.formatIri)((0, _fedify_vocab_runtime.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 _fedify_vocab.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 _fedify_vocab_runtime_jsonld.default.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$1.Instant.from(expires.value);
+		} catch {
+			return false;
+		}
+		if (Temporal$1.Instant.compare(Temporal$1.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, _fedify_vocab.Multikey, {
+		...options,
+		keyIdBoundByCaller
+	}));
+	const proofBytes = new TextEncoder().encode((0, json_canon.default)(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 = (0, json_canon.default)(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 _fedify_vocab_runtime_jsonld.default.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 = (0, _fedify_vocab_runtime.parseIri)(id);
+	(0, _fedify_vocab_runtime.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 _fedify_vocab.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 {
+			(0, _fedify_vocab_runtime.getFe34Origin)(verificationMethod);
+		} catch (error) {
+			if (!(error instanceof TypeError)) throw error;
+			return {
+				prepared: false,
+				result: {
+					verified: false,
+					reason: {
+						type: "unsupportedVerificationMethod",
+						proofIndex,
+						verificationMethod
+					}
+				}
+			};
+		}
+		if (!(0, _fedify_vocab_runtime.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: (0, _fedify_vocab_runtime.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 = (0, _logtape_logtape.getLogger)([
+		"fedify",
+		"sig",
+		"proof"
+	]);
+	const object = await cls.fromJsonLd(jsonLd, options);
+	const defaultDocumentLoader = (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const proofContextLoader = options.contextLoader ?? defaultDocumentLoader;
+	const attributions = new Set(object.attributionIds.map((uri) => uri.href));
+	if (object instanceof _fedify_vocab.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 _fedify_vocab.DataIntegrityProof.fromJsonLd(remoteDocument.document, {
+					documentLoader: baseDocumentLoader,
+					contextLoader: proofContextLoader,
+					tracerProvider: options.tracerProvider,
+					baseUrl: (0, _fedify_vocab_runtime.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) && (0, _fedify_vocab_runtime.haveSameFe34Origin)(controllerId, verificationMethodId);
+	if (!controllerHasCryptographicOrigin || verificationMethodMatchesController) attributions.delete(controllerId.href);
+	if (!verificationMethodMatchesController) return;
+	for (const attribution of [...attributions]) if (hasCryptographicOrigin(attribution) && (0, _fedify_vocab_runtime.haveSameFe34Origin)(controllerId, attribution)) attributions.delete(attribution);
+}
+function hasCryptographicOrigin(iri) {
+	return /^did:/i.test(iri) || /^ap(?:\+ef61)?:\/\//i.test(iri);
+}
+//#endregion
+//#region src/sig/portable-key.ts
+const logger = (0, _logtape_logtape.getLogger)([
+	"fedify",
+	"sig",
+	"key"
+]);
+const SEC = "https://w3id.org/security#";
+/**
+* Verifies that the signed document of a portable actor vouches for
+* the gateway key with the given ID.
+*
+* A gateway key is accepted only if:
+*
+*  -  the document is an actor whose portable ID is the one the key ID is
+*     the compatible identifier of;
+*  -  the document has a valid [FEP-8b32] Object Integrity Proof made by
+*     the DID of its ID, i.e., it satisfies the [FEP-ef61] proof policy;
+*  -  the document embeds a `Multikey` with that ID in its `assertionMethod`,
+*     whose `controller` is the actor, as [FEP-521a] requires; a key
+*     embedded in its `publicKey` with the same ID must agree with it; and
+*  -  the key ID's origin is one of the actor's `gateways`.
+*
+* [FEP-8b32]: https://w3id.org/fep/8b32
+* [FEP-ef61]: https://w3id.org/fep/ef61
+* [FEP-521a]: https://w3id.org/fep/521a
+*
+* @param document The raw JSON-LD document served at the key ID.
+* @param actor The parsed document, which must be a portable actor.
+* @param keyId The key ID, which must be a compatible key ID.
+* @param options Loaders and telemetry providers.
+* @returns The verification result, which is never `legacy`.
+* @internal
+*/
+async function verifyPortableGatewayKeyDocument(document, actor, keyId, options = {}) {
+	const reject = (reason) => {
+		logger.debug("Failed to verify gateway key {keyId} of the portable actor {actorId}: {reason}", {
+			keyId: keyId.href,
+			actorId: actor.id?.href,
+			reason
+		});
+		return {
+			type: "rejected",
+			reason
+		};
+	};
+	const keyBase = new URL(keyId.href);
+	keyBase.hash = "";
+	const claimedActorId = getCanonicalPortableId(keyBase);
+	const actorId = actor.id == null ? null : getCanonicalPortableId(actor.id);
+	if (claimedActorId == null || actorId == null) return reject("The key ID or the actor ID is not a valid portable ID.");
+	if (claimedActorId !== actorId) return reject("The key ID is not a compatible identifier of the actor it dereferences to.");
+	let verification;
+	try {
+		verification = await verifyPortableObjectProofWithRoot(document, {
+			documentLoader: options.documentLoader,
+			contextLoader: options.contextLoader,
+			keyCache: options.keyCache,
+			tracerProvider: options.tracerProvider,
+			meterProvider: options.meterProvider
+		});
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return reject(`The actor document is malformed: ${error.message}`);
+	}
+	const { result, root } = verification;
+	if (!result.verified) return reject("The actor document does not satisfy the FEP-ef61 proof policy: " + result.reason.type);
+	if (root == null) return reject("The actor document could not be expanded.");
+	const refuse = (url) => Promise.reject(/* @__PURE__ */ new Error(`Refusing to fetch ${url}.`));
+	let verifiedActor;
+	try {
+		verifiedActor = await _fedify_vocab.Object.fromJsonLd(root, {
+			documentLoader: refuse,
+			contextLoader: options.contextLoader,
+			tracerProvider: options.tracerProvider
+		});
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return reject("The verified actor document is malformed.");
+	}
+	if (!isPortableActorDocument(verifiedActor) || getCanonicalPortableId(verifiedActor.id) !== claimedActorId) return reject("The key ID is not a compatible identifier of the actor whose document is signed.");
+	actor = verifiedActor;
+	const multikeyNode = findEmbeddedNode(root[`${SEC}assertionMethod`], keyId);
+	if (multikeyNode == null) return reject("The actor document does not embed the key in its assertionMethod.");
+	let multikey;
+	try {
+		multikey = await _fedify_vocab.Multikey.fromJsonLd(multikeyNode, {
+			documentLoader: refuse,
+			contextLoader: options.contextLoader,
+			tracerProvider: options.tracerProvider
+		});
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return reject("The key in the assertionMethod is malformed.");
+	}
+	if (multikey.publicKey == null) return reject("The key in the assertionMethod has no public key.");
+	if (multikey.controllerId == null || getCanonicalPortableId(multikey.controllerId) !== actorId) return reject("The controller of the key is not the actor.");
+	const publicKeyNode = findEmbeddedNode(root[`${SEC}publicKey`], keyId);
+	if (publicKeyNode != null) {
+		let publicKey;
+		try {
+			publicKey = await _fedify_vocab.CryptographicKey.fromJsonLd(publicKeyNode, {
+				documentLoader: refuse,
+				contextLoader: options.contextLoader,
+				tracerProvider: options.tracerProvider
+			});
+		} catch (error) {
+			if (!(error instanceof TypeError)) throw error;
+			return reject("The key in the publicKey is malformed.");
+		}
+		if (publicKey.publicKey == null || !await isSamePublicKey(publicKey.publicKey, multikey.publicKey) || publicKey.ownerId != null && getCanonicalPortableId(publicKey.ownerId) !== actorId) return reject("The key in the publicKey does not agree with the one in the assertionMethod.");
+	}
+	if (!actor.gateways.some((gateway) => (0, _fedify_vocab_runtime.isGatewayUrl)(gateway) && gateway.origin === keyId.origin)) return reject(`The gateway ${keyId.origin} is not listed in the actor's gateways.`);
+	const key = new _fedify_vocab.CryptographicKey({
+		id: keyId,
+		owner: actor.id,
+		publicKey: multikey.publicKey
+	});
+	return {
+		type: "verified",
+		actor,
+		key
+	};
+}
+/**
+* Fetches the document at a compatible key ID, and resolves the key as
+* a gateway key if the document is a portable actor.
+*
+* @param keyId The key ID, which must be a compatible key ID.
+* @param options Loaders and telemetry providers.
+* @returns `legacy` if the document cannot be fetched or is not a portable
+*          actor, which leaves the key to the usual resolution; otherwise,
+*          the result of {@link verifyPortableGatewayKeyDocument}.
+* @internal
+*/
+async function fetchPortableGatewayKey(keyId, options = {}) {
+	const documentLoader = options.documentLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	const contextLoader = options.contextLoader ?? (0, _fedify_vocab_runtime.getDocumentLoader)();
+	let remoteDocument;
+	try {
+		remoteDocument = await documentLoader(keyId.href);
+	} catch (error) {
+		logger.debug("Failed to fetch key {keyId}: {error}", {
+			keyId: keyId.href,
+			error
+		});
+		return { type: "legacy" };
+	}
+	let object;
+	try {
+		object = await _fedify_vocab.Object.fromJsonLd(remoteDocument.document, {
+			documentLoader,
+			contextLoader,
+			tracerProvider: options.tracerProvider
+		});
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		return { type: "legacy" };
+	}
+	if (!isPortableActorDocument(object)) return { type: "legacy" };
+	return await verifyPortableGatewayKeyDocument(remoteDocument.document, object, keyId, {
+		...options,
+		documentLoader,
+		contextLoader
+	});
+}
+function findEmbeddedNode(values, id) {
+	if (!Array.isArray(values)) return null;
+	for (const value of values) {
+		if (value == null || typeof value !== "object" || Array.isArray(value)) continue;
+		const node = value;
+		const nodeId = node["@id"];
+		if (typeof nodeId !== "string") continue;
+		let parsed;
+		try {
+			parsed = new URL(nodeId);
+		} catch {
+			continue;
+		}
+		if (parsed.href !== id.href) continue;
+		if (Object.keys(node).every((key) => key === "@id")) continue;
+		return node;
+	}
+	return null;
+}
+//#endregion
+//#region src/sig/http.ts
+const Temporal = Temporal$2;
+const DEFAULT_MAX_REDIRECTION = 20;
+const DOUBLE_KNOCK_TRANSPORT_RETRY_DELAY_MS = 100;
+/**
+* Signs a request using the given private key.
+* @param request The request to sign.
+* @param privateKey The private key to use for signing.
+* @param keyId The key ID to use for the signature.  It will be used by the
+*              verifier.
+* @returns The signed request.
+* @throws {TypeError} If the private key is invalid or unsupported.
+*/
+async function signRequest(request, privateKey, keyId, options = {}) {
+	validateCryptoKey(privateKey, "private");
+	return await (options.tracerProvider ?? _opentelemetry_api.trace.getTracerProvider()).getTracer(name, version).startActiveSpan("http_signatures.sign", async (span) => {
+		try {
+			const spec = options.spec ?? "draft-cavage-http-signatures-12";
+			let signed;
+			if (spec === "rfc9421") signed = await signRequestRfc9421(request, privateKey, keyId, span, options.currentTime, options.body, options.rfc9421);
+			else signed = await signRequestDraft(request, privateKey, keyId, span, options.currentTime, options.body);
+			if (span.isRecording()) {
+				span.setAttribute(_opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_METHOD, signed.method);
+				span.setAttribute(_opentelemetry_semantic_conventions.ATTR_URL_FULL, signed.url);
+				for (const [name, value] of signed.headers) span.setAttribute((0, _opentelemetry_semantic_conventions.ATTR_HTTP_REQUEST_HEADER)(name), value);
+				span.setAttribute("http_signatures.key_id", keyId.href);
+			}
+			return signed;
+		} catch (error) {
+			span.setStatus({
+				code: _opentelemetry_api.SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			span.end();
+		}
+	});
+}
+async function signRequestDraft(request, privateKey, keyId, span, currentTime, bodyBuffer) {
+	if (privateKey.algorithm.name !== "RSASSA-PKCS1-v1_5") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
+	const url = new URL(request.url);
+	const body = bodyBuffer !== void 0 ? bodyBuffer : request.method !== "GET" && request.method !== "HEAD" ? await request.clone().arrayBuffer() : null;
+	const headers = new Headers(request.headers);
+	if (!headers.has("Host")) headers.set("Host", url.host);
+	if (!headers.has("Digest") && body != null) {
+		const digest = await crypto.subtle.digest("SHA-256", body);
+		headers.set("Digest", `SHA-256=${(0, byte_encodings_base64.encodeBase64)(digest)}`);
+		if (span.isRecording()) span.setAttribute("http_signatures.digest.sha-256", (0, byte_encodings_hex.encodeHex)(digest));
+	}
+	if (!headers.has("Date")) headers.set("Date", currentTime == null ? (/* @__PURE__ */ new Date()).toUTCString() : new Date(currentTime.toString()).toUTCString());
+	const serialized = [["(request-target)", `${request.method.toLowerCase()} ${url.pathname}`], ...headers];
+	const headerNames = serialized.map(([name]) => name);
+	const message = serialized.map(([name, value]) => `${name}: ${value.trim()}`).join("\n");
+	const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", privateKey, new TextEncoder().encode(message));
+	const sigHeader = `keyId="${keyId.href}",algorithm="rsa-sha256",headers="${headerNames.join(" ")}",signature="${(0, byte_encodings_base64.encodeBase64)(signature)}"`;
 	headers.set("Signature", sigHeader);
 	if (span.isRecording()) {
 		span.setAttribute("http_signatures.algorithm", "rsa-sha256");
@@ -5687,7 +8117,14 @@ async function verifyRequestDraft(request, span, metricsContext, { documentLoade
 		contextLoader,
 		keyCache,
 		tracerProvider,
-		meterProvider
+		meterProvider,
+		portableGatewayKeyResolver: (document, actor, keyId) => verifyPortableGatewayKeyDocument(document, actor, keyId, {
+			documentLoader,
+			contextLoader,
+			keyCache,
+			tracerProvider,
+			meterProvider
+		})
 	}));
 	if (fetchError != null) return keyFetchErrorResult(keyIdUrl, fetchError);
 	if (key == null) return invalidSignatureResult(keyIdUrl);
@@ -5903,7 +8340,14 @@ async function verifyRequestRfc9421(request, span, metricsContext, { documentLoa
 			contextLoader,
 			keyCache,
 			tracerProvider,
-			meterProvider
+			meterProvider,
+			portableGatewayKeyResolver: (document, actor, gatewayKeyId) => verifyPortableGatewayKeyDocument(document, actor, gatewayKeyId, {
+				documentLoader,
+				contextLoader,
+				keyCache,
+				tracerProvider,
+				meterProvider
+			})
 		}));
 		if (fetchError != null) {
 			setFailure(keyFetchErrorResult(keyId, fetchError));
@@ -6208,10 +8652,52 @@ function timingSafeEqual(a, b) {
 	return result === 0;
 }
 //#endregion
+Object.defineProperty(exports, "InvalidContextReferenceError", {
+	enumerable: true,
+	get: function() {
+		return InvalidContextReferenceError;
+	}
+});
 Object.defineProperty(exports, "Temporal", {
 	enumerable: true,
 	get: function() {
-		return Temporal$1;
+		return Temporal$2;
+	}
+});
+Object.defineProperty(exports, "assertSafeJsonLd", {
+	enumerable: true,
+	get: function() {
+		return assertSafeJsonLd;
+	}
+});
+Object.defineProperty(exports, "attachSignature", {
+	enumerable: true,
+	get: function() {
+		return attachSignature;
+	}
+});
+Object.defineProperty(exports, "compactJsonLd", {
+	enumerable: true,
+	get: function() {
+		return compactJsonLd;
+	}
+});
+Object.defineProperty(exports, "createProof", {
+	enumerable: true,
+	get: function() {
+		return createProof;
+	}
+});
+Object.defineProperty(exports, "createSignature", {
+	enumerable: true,
+	get: function() {
+		return createSignature;
+	}
+});
+Object.defineProperty(exports, "detachSignature", {
+	enumerable: true,
+	get: function() {
+		return detachSignature;
 	}
 });
 Object.defineProperty(exports, "doubleKnock", {
@@ -6244,6 +8730,12 @@ Object.defineProperty(exports, "fetchKeyDetailed", {
 		return fetchKeyDetailed;
 	}
 });
+Object.defineProperty(exports, "fetchPortableGatewayKey", {
+	enumerable: true,
+	get: function() {
+		return fetchPortableGatewayKey;
+	}
+});
 Object.defineProperty(exports, "formatAcceptSignature", {
 	enumerable: true,
 	get: function() {
@@ -6262,6 +8754,12 @@ Object.defineProperty(exports, "generateCryptoKeyPair", {
 		return generateCryptoKeyPair;
 	}
 });
+Object.defineProperty(exports, "getCanonicalPortableId", {
+	enumerable: true,
+	get: function() {
+		return getCanonicalPortableId;
+	}
+});
 Object.defineProperty(exports, "getDurationMs", {
 	enumerable: true,
 	get: function() {
@@ -6274,12 +8772,48 @@ Object.defineProperty(exports, "getFederationMetrics", {
 		return getFederationMetrics;
 	}
 });
+Object.defineProperty(exports, "getGatewayKeyBase", {
+	enumerable: true,
+	get: function() {
+		return getGatewayKeyBase;
+	}
+});
+Object.defineProperty(exports, "getNormalizationContextLoader", {
+	enumerable: true,
+	get: function() {
+		return getNormalizationContextLoader;
+	}
+});
 Object.defineProperty(exports, "getRemoteHost", {
 	enumerable: true,
 	get: function() {
 		return getRemoteHost;
 	}
 });
+Object.defineProperty(exports, "hasPortableActor", {
+	enumerable: true,
+	get: function() {
+		return hasPortableActor;
+	}
+});
+Object.defineProperty(exports, "hasProofLike", {
+	enumerable: true,
+	get: function() {
+		return hasProofLike;
+	}
+});
+Object.defineProperty(exports, "hasSignature", {
+	enumerable: true,
+	get: function() {
+		return hasSignature;
+	}
+});
+Object.defineProperty(exports, "hasSignatureLike", {
+	enumerable: true,
+	get: function() {
+		return hasSignatureLike;
+	}
+});
 Object.defineProperty(exports, "importJwk", {
 	enumerable: true,
 	get: function() {
@@ -6298,10 +8832,34 @@ Object.defineProperty(exports, "isAbortError", {
 		return isAbortError$1;
 	}
 });
-Object.defineProperty(exports, "measureSignatureKeyFetch", {
+Object.defineProperty(exports, "isClearlyMalformedContextReference", {
+	enumerable: true,
+	get: function() {
+		return isClearlyMalformedContextReference;
+	}
+});
+Object.defineProperty(exports, "isCompatibleKeyId", {
 	enumerable: true,
 	get: function() {
-		return measureSignatureKeyFetch;
+		return isCompatibleKeyId;
+	}
+});
+Object.defineProperty(exports, "isInvalidUrlTypeError", {
+	enumerable: true,
+	get: function() {
+		return isInvalidUrlTypeError;
+	}
+});
+Object.defineProperty(exports, "isPortableUri", {
+	enumerable: true,
+	get: function() {
+		return isPortableUri;
+	}
+});
+Object.defineProperty(exports, "isSamePublicKey", {
+	enumerable: true,
+	get: function() {
+		return isSamePublicKey;
 	}
 });
 Object.defineProperty(exports, "name", {
@@ -6310,6 +8868,12 @@ Object.defineProperty(exports, "name", {
 		return name;
 	}
 });
+Object.defineProperty(exports, "normalizeOutgoingActivityJsonLd", {
+	enumerable: true,
+	get: function() {
+		return normalizeOutgoingActivityJsonLd;
+	}
+});
 Object.defineProperty(exports, "parseAcceptSignature", {
 	enumerable: true,
 	get: function() {
@@ -6394,6 +8958,18 @@ Object.defineProperty(exports, "registerQueueDepthGauge", {
 		return registerQueueDepthGauge;
 	}
 });
+Object.defineProperty(exports, "signJsonLd", {
+	enumerable: true,
+	get: function() {
+		return signJsonLd;
+	}
+});
+Object.defineProperty(exports, "signObject", {
+	enumerable: true,
+	get: function() {
+		return signObject;
+	}
+});
 Object.defineProperty(exports, "signRequest", {
 	enumerable: true,
 	get: function() {
@@ -6412,12 +8988,60 @@ Object.defineProperty(exports, "validateCryptoKey", {
 		return validateCryptoKey;
 	}
 });
+Object.defineProperty(exports, "verifyCompactJsonLd", {
+	enumerable: true,
+	get: function() {
+		return verifyCompactJsonLd;
+	}
+});
+Object.defineProperty(exports, "verifyJsonLd", {
+	enumerable: true,
+	get: function() {
+		return verifyJsonLd;
+	}
+});
 Object.defineProperty(exports, "verifyKeyOwnership", {
 	enumerable: true,
 	get: function() {
 		return verifyKeyOwnership;
 	}
 });
+Object.defineProperty(exports, "verifyMapLocalProof", {
+	enumerable: true,
+	get: function() {
+		return verifyMapLocalProof;
+	}
+});
+Object.defineProperty(exports, "verifyObject", {
+	enumerable: true,
+	get: function() {
+		return verifyObject;
+	}
+});
+Object.defineProperty(exports, "verifyPortableObjectProof", {
+	enumerable: true,
+	get: function() {
+		return verifyPortableObjectProof;
+	}
+});
+Object.defineProperty(exports, "verifyPortableObjectProofPolicy", {
+	enumerable: true,
+	get: function() {
+		return verifyPortableObjectProofPolicy;
+	}
+});
+Object.defineProperty(exports, "verifyPortableObjectProofWithRoot", {
+	enumerable: true,
+	get: function() {
+		return verifyPortableObjectProofWithRoot;
+	}
+});
+Object.defineProperty(exports, "verifyProof", {
+	enumerable: true,
+	get: function() {
+		return verifyProof;
+	}
+});
 Object.defineProperty(exports, "verifyRequest", {
 	enumerable: true,
 	get: function() {
@@ -6430,9 +9054,21 @@ Object.defineProperty(exports, "verifyRequestDetailed", {
 		return verifyRequestDetailed;
 	}
 });
+Object.defineProperty(exports, "verifySignature", {
+	enumerable: true,
+	get: function() {
+		return verifySignature;
+	}
+});
 Object.defineProperty(exports, "version", {
 	enumerable: true,
 	get: function() {
 		return version;
 	}
 });
+Object.defineProperty(exports, "wrapContextLoaderForJsonLd", {
+	enumerable: true,
+	get: function() {
+		return wrapContextLoaderForJsonLd;
+	}
+});