@fedify/fedify 2.4.0-pr.936.41 → 2.5.0-dev.2271

package/dist/compound-proof-B-9mXxFW.mjs

@@ -0,0 +1,989 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { a as getRawCanonicalPortableId, l as isPortableId, n as getCanonicalPortableId } from "./portable-key-id-Ca30-hOa.mjs";
+import { a as verificationObservation, t as observeAttempt } from "./verification-Dpfcw8ml.mjs";
+import { n as preloadedOnlyDocumentLoader } from "./public-audience--klBIOk1.mjs";
+import { c as getNormalizationContextLoader } from "./ld-CzaP-hJl.mjs";
+import { l as verifyPortableObjectProofPolicy, n as classifyFep2277CoreType, o as verifyMapLocalProof } from "./proof-Dxy6ByqI.mjs";
+import { parseIri, preloadedContexts } from "@fedify/vocab-runtime";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+//#region src/sig/compound-proof.ts
+const textEncoder = new TextEncoder();
+/**
+* Checks whether a literal `id` or `@id` value makes a map a portable object:
+* an `ap:` or `ap+ef61:` URI, or anything that looks like an FEP-ef61
+* compatible identifier, even a malformed one, which then fails the policy.
+*/
+function isPortableIdValue(value) {
+	return typeof value === "string" && isPortableId(value);
+}
+function isJsonMap(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function isCompoundProofJsonObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function hasOnlyDataProperties(value) {
+	try {
+		return Reflect.ownKeys(value).every((key) => {
+			if (typeof key !== "string") return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			return descriptor != null && "value" in descriptor && descriptor.enumerable;
+		});
+	} catch {
+		return false;
+	}
+}
+function hasOnlyJsonArrayProperties(value) {
+	try {
+		const keys = Reflect.ownKeys(value);
+		if (keys.length !== value.length + 1) return false;
+		for (const key of keys) {
+			if (key === "length") continue;
+			if (typeof key !== "string") return false;
+			const index = Number(key);
+			if (!Number.isInteger(index) || index < 0 || index >= value.length || String(index) !== key) return false;
+			const descriptor = Object.getOwnPropertyDescriptor(value, key);
+			if (descriptor == null || !descriptor.enumerable || !("value" in descriptor)) return false;
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+function escapeJsonPointerSegment(segment) {
+	return segment.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function childPath(path, segment) {
+	return `${path}/${escapeJsonPointerSegment(segment)}`;
+}
+function comparePaths(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function encodedLength(value) {
+	return textEncoder.encode(value).byteLength;
+}
+function validateLimits(limits) {
+	for (const [name, value] of Object.entries(limits)) if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name} must be a non-negative safe integer.`);
+}
+function limitExceeded(limit, maximum, actual, path) {
+	return {
+		status: "unsupported",
+		reason: {
+			type: "limitExceeded",
+			limit,
+			maximum,
+			actual,
+			path
+		}
+	};
+}
+function addBytes(statistics, bytes, limits, path) {
+	statistics.byteLength += bytes;
+	if (statistics.byteLength > limits.maxBytes) return limitExceeded("bytes", limits.maxBytes, statistics.byteLength, path);
+}
+function inspectJsonTree(root, limits) {
+	if (!isJsonMap(root)) return {
+		status: "unsupported",
+		reason: {
+			type: "invalidJsonTree",
+			path: ""
+		}
+	};
+	const statistics = {
+		byteLength: 0,
+		mapCount: 0,
+		proofCount: 0,
+		maxDepth: 0
+	};
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: root,
+		path: "",
+		depth: 0,
+		insideProof: false,
+		insideContext: false
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		statistics.maxDepth = Math.max(statistics.maxDepth, current.depth);
+		if (current.depth > limits.maxDepth) return limitExceeded("depth", limits.maxDepth, current.depth, current.path);
+		const value = current.value;
+		if (value === null) {
+			const failure = addBytes(statistics, 4, limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "boolean") {
+			const failure = addBytes(statistics, value ? 4 : 5, limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "string") {
+			const failure = addBytes(statistics, encodedLength(JSON.stringify(value)), limits, current.path);
+			if (failure != null) return failure;
+		} else if (typeof value === "number") {
+			if (!Number.isFinite(value)) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			const failure = addBytes(statistics, encodedLength(JSON.stringify(value)), limits, current.path);
+			if (failure != null) return failure;
+		} else if (Array.isArray(value)) {
+			if (seen.has(value) || !hasOnlyJsonArrayProperties(value)) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			seen.add(value);
+			const failure = addBytes(statistics, 2 + Math.max(0, value.length - 1), limits, current.path);
+			if (failure != null) return failure;
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1,
+				insideProof: current.insideProof,
+				insideContext: current.insideContext
+			});
+		} else if (isJsonMap(value)) {
+			const prototype = Object.getPrototypeOf(value);
+			if (seen.has(value) || !hasOnlyDataProperties(value) || prototype !== Object.prototype && prototype !== null) return {
+				status: "unsupported",
+				reason: {
+					type: "invalidJsonTree",
+					path: current.path
+				}
+			};
+			seen.add(value);
+			statistics.mapCount++;
+			if (statistics.mapCount > limits.maxMaps) return limitExceeded("maps", limits.maxMaps, statistics.mapCount, current.path);
+			const entries = Object.entries(value).sort(([left], [right]) => comparePaths(left, right));
+			let objectBytes = 2 + Math.max(0, entries.length - 1);
+			for (const [key] of entries) objectBytes += encodedLength(JSON.stringify(key)) + 1;
+			const failure = addBytes(statistics, objectBytes, limits, current.path);
+			if (failure != null) return failure;
+			const hasDirectProof = !current.insideProof && !current.insideContext && Object.hasOwn(value, "proof");
+			if (hasDirectProof) {
+				statistics.proofCount++;
+				if (statistics.proofCount > limits.maxProofs) return limitExceeded("proofs", limits.maxProofs, statistics.proofCount, childPath(current.path, "proof"));
+				if (!isJsonMap(value.proof)) return {
+					status: "unsupported",
+					reason: {
+						type: "unsupportedProofShape",
+						path: childPath(current.path, "proof")
+					}
+				};
+			}
+			for (let index = entries.length - 1; index >= 0; index--) {
+				const [key, child] = entries[index];
+				pending.push({
+					value: child,
+					path: childPath(current.path, key),
+					depth: current.depth + 1,
+					insideProof: current.insideProof || hasDirectProof && key === "proof",
+					insideContext: current.insideContext || key === "@context"
+				});
+			}
+		} else return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: current.path
+			}
+		};
+	}
+	return statistics;
+}
+function freezeJsonTree(root) {
+	const pending = [root];
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (typeof value !== "object" || value == null) continue;
+		if (Array.isArray(value)) for (const child of value) pending.push(child);
+		else for (const child of Object.values(value)) pending.push(child);
+		Object.freeze(value);
+	}
+}
+function collectDocuments(snapshot) {
+	const documents = [];
+	const pending = [{
+		value: snapshot,
+		path: "",
+		depth: 0
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (Array.isArray(current.value)) {
+			for (let index = current.value.length - 1; index >= 0; index--) pending.push({
+				value: current.value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1
+			});
+			continue;
+		}
+		if (!isCompoundProofJsonObject(current.value)) continue;
+		const document = current.value;
+		if (Object.hasOwn(document, "proof")) {
+			const proof = document.proof;
+			const id = typeof document.id === "string" ? document.id : typeof document["@id"] === "string" ? document["@id"] : void 0;
+			documents.push(Object.freeze({
+				path: current.path,
+				id,
+				depth: current.depth,
+				securedDocument: document,
+				proof
+			}));
+		}
+		const entries = Object.entries(document).sort(([left], [right]) => comparePaths(left, right));
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const [key, value] = entries[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value,
+				path: childPath(current.path, key),
+				depth: current.depth + 1
+			});
+		}
+	}
+	documents.sort((left, right) => right.depth - left.depth || comparePaths(left.path, right.path));
+	return documents;
+}
+function collectPortableObjects(snapshot) {
+	const objects = [];
+	const pending = [{
+		value: snapshot,
+		path: "",
+		depth: 0
+	}];
+	while (pending.length > 0) {
+		const current = pending.pop();
+		if (Array.isArray(current.value)) {
+			for (let index = current.value.length - 1; index >= 0; index--) pending.push({
+				value: current.value[index],
+				path: childPath(current.path, String(index)),
+				depth: current.depth + 1,
+				keyOf: current.keyOf
+			});
+			continue;
+		}
+		if (!isCompoundProofJsonObject(current.value)) continue;
+		const document = current.value;
+		const id = [document.id, document["@id"]].find(isPortableIdValue);
+		if (typeof id === "string") objects.push(Object.freeze({
+			path: current.path,
+			id,
+			depth: current.depth,
+			document,
+			...current.keyOf == null ? {} : { keyOf: current.keyOf }
+		}));
+		const entries = Object.entries(document).sort(([left], [right]) => comparePaths(left, right));
+		for (let index = entries.length - 1; index >= 0; index--) {
+			const [key, value] = entries[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value,
+				path: childPath(current.path, key),
+				depth: current.depth + 1,
+				...typeof id === "string" && (key === "publicKey" || key === "assertionMethod") ? { keyOf: {
+					path: current.path,
+					member: key
+				} } : {}
+			});
+		}
+	}
+	objects.sort((left, right) => right.depth - left.depth || comparePaths(left.path, right.path));
+	return objects;
+}
+/**
+* Determines whether a received JSON tree contains a portable object ID, i.e.,
+* an `ap:` or `ap+ef61:` URI or an FEP-ef61 compatible identifier, outside
+* a proof or context definition, without exceeding discovery limits.
+*
+* This is only an applicability check.  It does not authenticate the input;
+* callers must still use {@link verifyCompoundPortableObjectProofs} to obtain
+* an atomic result from an immutable snapshot.  `indeterminate` means the
+* applicability scan itself reached a limit, so a caller must not treat the
+* document as outside the compound profile.
+*
+* @internal
+*/
+function inspectCompoundPortableObjectApplicability(json, limits) {
+	validateLimits(limits);
+	let byteLength = 0;
+	let mapCount = 0;
+	const pending = [{
+		iterator: [json].values(),
+		depth: 0
+	}];
+	const addByteLength = (length) => {
+		byteLength += length;
+		return byteLength <= limits.maxBytes;
+	};
+	while (pending.length > 0) {
+		const frame = pending[pending.length - 1];
+		const next = frame.iterator.next();
+		if (next.done) {
+			pending.pop();
+			if (byteLength > limits.maxBytes) return "indeterminate";
+			continue;
+		}
+		const value = next.value;
+		if (frame.depth > limits.maxDepth) return "indeterminate";
+		if (value === null) {
+			if (!addByteLength(4)) return "indeterminate";
+		} else if (typeof value === "boolean") {
+			if (!addByteLength(value ? 4 : 5)) return "indeterminate";
+		} else if (typeof value === "string" || typeof value === "number") {
+			if (!addByteLength(encodedLength(JSON.stringify(value)))) return "indeterminate";
+		} else if (Array.isArray(value)) {
+			if (!addByteLength(2 + Math.max(0, value.length - 1))) return "indeterminate";
+			pending.push({
+				iterator: value.values(),
+				depth: frame.depth + 1
+			});
+		} else if (isJsonMap(value)) {
+			mapCount++;
+			if (mapCount > limits.maxMaps) return "indeterminate";
+			if ([value.id, value["@id"]].some(isPortableIdValue)) return "present";
+			if (!addByteLength(2)) return "indeterminate";
+			const children = function* () {
+				let first = true;
+				for (const key in value) {
+					if (!Object.hasOwn(value, key)) continue;
+					if (key === "proof" || key === "@context") continue;
+					if (!first && !addByteLength(1)) return;
+					first = false;
+					if (!addByteLength(encodedLength(JSON.stringify(key)) + 1)) return;
+					yield value[key];
+				}
+			}();
+			pending.push({
+				iterator: children,
+				depth: frame.depth + 1
+			});
+		}
+		if (byteLength > limits.maxBytes) return "indeterminate";
+	}
+	return "absent";
+}
+/**
+* Walks every JSON map in a finite, already-materialized JSON tree, depth
+* first in insertion order, skipping the values of `proof` and `@context`
+* members.  A map reached a second time through a repeated reference is not
+* visited again, so a cyclic input terminates.  The walk stops as soon as
+* the visitor returns a value other than `undefined`.
+*/
+function findInJsonMaps(json, visit) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: json,
+		path: ""
+	}];
+	while (pending.length > 0) {
+		const { value, path } = pending.pop();
+		if (typeof value !== "object" || value == null || seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(path, String(index))
+			});
+			continue;
+		}
+		const map = value;
+		const result = visit(map, path);
+		if (result !== void 0) return result;
+		const keys = Object.keys(map);
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value: map[key],
+				path: childPath(path, key)
+			});
+		}
+	}
+}
+/**
+* Determines whether an outgoing JSON tree contains portable content that
+* requires producer-side proof-shape checks: a map, outside proof and context
+* values, whose direct `id` or `@id` is a portable ActivityPub URI or an
+* FEP-ef61 compatible identifier.
+*
+* This deliberately differs from
+* {@link inspectCompoundPortableObjectApplicability}: it applies no resource
+* limits, so a portable map or an unsupported proof beyond the inbox limits
+* is still found, and a large document without portable maps stays outside
+* the compound-proof profile.  The input must be a finite JSON tree that has
+* already been materialized, such as a compact JSON-LD document about to be
+* sent.
+*
+* @internal
+*/
+function containsCompoundPortableObject(json) {
+	return findInJsonMaps(json, (map) => [map.id, map["@id"]].some(isPortableIdValue) ? true : void 0) ?? false;
+}
+/**
+* Finds the first direct `proof` member whose value the map-local
+* compound-proof profile does not accept, i.e., anything other than a single
+* JSON map: a proof set, `null`, or a scalar.  Like the inbox discovery, it
+* does not look inside proof or context values.
+*
+* The input must be a finite, already-materialized JSON tree; see
+* {@link containsCompoundPortableObject}.
+*
+* @returns The RFC 6901 JSON Pointer to the unsupported `proof` member, or
+*          `null` if every direct proof is a single JSON map.
+* @internal
+*/
+function findUnsupportedCompoundProofShape(json) {
+	return findInJsonMaps(json, (map, path) => Object.hasOwn(map, "proof") && !isJsonMap(map.proof) ? childPath(path, "proof") : void 0) ?? null;
+}
+/**
+* Finds the first embedded map that carries a direct `proof` but not its own
+* `@context`.  The map-local compound-proof profile verifies each proof-bearing
+* map as a self-contained document, so the inbox rejects such a map with
+* `missingContext` whatever its proof.  An object embedded with its captured
+* signed representation, e.g., by {@link signObject}, always keeps its own
+* `@context`; one rebuilt under its parent's context, e.g., an object parsed
+* from a received document, never does, and its proof no longer covers what
+* it has become anyway.
+*
+* The input must be a finite, already-materialized JSON tree; see
+* {@link containsCompoundPortableObject}.
+*
+* @returns The RFC 6901 JSON Pointer to the map, or `null` if every embedded
+*          proof-bearing map has its own `@context`.
+* @internal
+*/
+function findEmbeddedProofWithoutContext(json) {
+	return findInJsonMaps(json, (map, path) => path !== "" && Object.hasOwn(map, "proof") && !Object.hasOwn(map, "@context") ? path : void 0) ?? null;
+}
+/**
+* Discovers direct literal proof-bearing maps in an immutable JSON snapshot.
+*
+* Discovery is bounded and atomic.  Unsupported proof shapes, non-JSON input,
+* or a resource-limit failure return no partial candidate list.  Proof
+* configuration subtrees are validated and counted as JSON, but are not
+* themselves searched for secured documents.
+*/
+function discoverCompoundProofDocuments(json, limits) {
+	validateLimits(limits);
+	let inspected;
+	try {
+		inspected = inspectJsonTree(json, limits);
+	} catch {
+		return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: ""
+			}
+		};
+	}
+	if ("status" in inspected) return inspected;
+	let snapshot;
+	try {
+		snapshot = structuredClone(json);
+	} catch {
+		return {
+			status: "unsupported",
+			reason: {
+				type: "invalidJsonTree",
+				path: ""
+			}
+		};
+	}
+	freezeJsonTree(snapshot);
+	return {
+		status: "ok",
+		snapshot,
+		documents: Object.freeze(collectDocuments(snapshot)),
+		statistics: Object.freeze({ ...inspected })
+	};
+}
+/**
+* Verifies every direct literal proof found in one immutable JSON snapshot.
+*
+* Each current map is verified independently.  Only its literal `proof`
+* member is removed from its JCS input, so descendant proofs and proof aliases
+* remain unchanged.  This is the lower-level compound-document mechanism; it
+* does not apply portable-object policy or authenticate an inbox activity.
+*
+* @internal
+*/
+async function verifyCompoundProofDocuments(json, limits, options = {}) {
+	const discovered = discoverCompoundProofDocuments(json, limits);
+	if (discovered.status !== "ok") return discovered;
+	const documents = await verifyDiscoveredProofDocuments(discovered, options);
+	return {
+		status: "ok",
+		verified: documents.length > 0 && documents.every((document) => document.verified),
+		snapshot: discovered.snapshot,
+		documents,
+		statistics: discovered.statistics
+	};
+}
+async function verifyDiscoveredProofDocuments(discovered, options) {
+	const documents = await Promise.all(discovered.documents.map(async (document) => {
+		const metadata = {
+			path: document.path,
+			...document.id == null ? {} : { id: document.id },
+			depth: document.depth
+		};
+		if (document.depth > 0 && !Object.hasOwn(document.securedDocument, "@context")) return Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "missingContext" }
+		});
+		const inherited = options[verificationObservation];
+		let subjectId = null;
+		if (inherited != null && document.id != null) try {
+			subjectId = parseIri(document.id);
+		} catch {}
+		const key = await observeAttempt({ [verificationObservation]: inherited == null ? void 0 : {
+			...inherited,
+			attempt: void 0,
+			check: void 0,
+			subject: {
+				id: subjectId,
+				pointer: document.path
+			}
+		} }, "objectIntegrity", (observation) => verifyMapLocalProof(document.securedDocument, {
+			...options,
+			[verificationObservation]: inherited == null ? void 0 : observation
+		}), (key) => key != null);
+		return key == null ? Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "invalidProof" }
+		}) : Object.freeze({
+			...metadata,
+			verified: true,
+			key
+		});
+	}));
+	return Object.freeze(documents);
+}
+/**
+* Applies FEP-ef61 portable-object policy to every portable map in a compound
+* snapshot without changing the map-local cryptographic inputs.
+*
+* @internal
+*/
+async function verifyCompoundPortableObjectProofs(json, limits, options = {}) {
+	const discovered = discoverCompoundProofDocuments(json, limits);
+	if (discovered.status !== "ok") return discovered;
+	const proofs = await verifyDiscoveredProofDocuments(discovered, options);
+	const proofByPath = new Map(proofs.map((proof) => [proof.path, proof]));
+	const verifyPortableObject = async (object) => {
+		const metadata = {
+			path: object.path,
+			id: object.id,
+			depth: object.depth
+		};
+		if (object.depth > 0 && !Object.hasOwn(object.document, "@context")) return Object.freeze({
+			...metadata,
+			verified: false,
+			reason: { type: "missingContext" }
+		});
+		const proof = proofByPath.get(object.path);
+		const key = proof?.verified === true ? proof.key : null;
+		try {
+			const policy = await verifyPortableObjectProofPolicy(object.document, key, options);
+			return policy.verified ? Object.freeze({
+				...metadata,
+				id: policy.objectId,
+				verified: true,
+				keys: policy.keys
+			}) : Object.freeze({
+				...metadata,
+				verified: false,
+				reason: policy.reason
+			});
+		} catch {
+			return Object.freeze({
+				...metadata,
+				verified: false,
+				reason: { type: "invalidPortableObject" }
+			});
+		}
+	};
+	const collected = collectPortableObjects(discovered.snapshot);
+	const objectByPath = new Map(collected.map((object) => [object.path, object]));
+	const isKeyCandidate = (object) => object.keyOf != null && !Object.hasOwn(object.document, "proof");
+	const results = /* @__PURE__ */ new Map();
+	for (const result of await Promise.all(collected.filter((object) => !isKeyCandidate(object)).map(verifyPortableObject))) results.set(result.path, result);
+	let projections = 0;
+	for (const object of collected) {
+		if (!isKeyCandidate(object)) continue;
+		const { path, member } = object.keyOf;
+		const parent = results.get(path);
+		const parentObject = objectByPath.get(path);
+		if (parent?.verified === true && parentObject != null && projections++ < MAX_KEY_PROJECTIONS && await isEmbeddedPortableKey(parentObject.document, member, object.document, parent.id)) continue;
+		results.set(object.path, await verifyPortableObject(object));
+	}
+	const portableObjects = Object.freeze(collected.flatMap((object) => {
+		const result = results.get(object.path);
+		return result == null ? [] : [result];
+	}));
+	return {
+		status: "ok",
+		verified: portableObjects.length > 0 && proofs.every((proof) => proof.verified) && portableObjects.every((object) => object.verified),
+		snapshot: discovered.snapshot,
+		proofs,
+		portableObjects,
+		statistics: discovered.statistics
+	};
+}
+/**
+* The maximum number of embedded keys per compound document that are checked
+* by {@link isEmbeddedPortableKey}, each of which expands a projection of its
+* parent.  Keys beyond it have to carry their own proofs.
+*/
+const MAX_KEY_PROJECTIONS = 64;
+const SECURITY = "https://w3id.org/security#";
+const KEY_TYPES = /* @__PURE__ */ new Set([`${SECURITY}Key`, `${SECURITY}Multikey`]);
+const KEY_PROPERTIES = /* @__PURE__ */ new Set([
+	"@id",
+	"@type",
+	`${SECURITY}owner`,
+	`${SECURITY}controller`,
+	`${SECURITY}publicKeyPem`,
+	`${SECURITY}publicKeyMultibase`
+]);
+/**
+* Tells whether an unsigned map embedded in a verified portable map is just
+* a key of the portable object the parent is, e.g., a gateway key of
+* a portable actor, which the parent's proof covers.
+*
+* The key's meaning depends on the contexts active where it sits, so it is
+* decided on a projection of the parent that keeps only what those contexts
+* depend on: the parent's `@context`, its types and ID, and the member that
+* holds the key.  That holds only if nothing else in the parent can change
+* them, so both documents may only use contexts that define no keyword
+* aliases and no scoped contexts; Fedify's preloaded contexts, the only
+* remote ones the compound policy loads, alias just `id` and `type`.
+*
+* The projection must expand to the parent's verified ID with the key as the
+* single value of `publicKey` or `assertionMethod`, and the key must be
+* nothing but a `CryptographicKey` or `Multikey` whose ID is the parent's
+* `ap:` or `ap+ef61:` URI, or its compatible identifier, plus a fragment,
+* and whose owner or controller, if any, is the parent.
+*/
+async function isEmbeddedPortableKey(parent, member, key, parentId) {
+	const parentPortableId = getCanonicalPortableIdOf(parentId);
+	if (parentPortableId == null) return false;
+	if (!isSimpleContext(parent["@context"]) || Object.hasOwn(key, "@context") && !isSimpleContext(key["@context"])) return false;
+	const literalIds = [key.id, key["@id"]].filter((id) => id !== void 0);
+	if (literalIds.length < 1 || literalIds.some((id) => id !== literalIds[0]) || typeof literalIds[0] !== "string" || !isKeyIdOf(literalIds[0], parentPortableId)) return false;
+	const projection = {};
+	for (const property of [
+		"@context",
+		"type",
+		"@type",
+		"id",
+		"@id"
+	]) if (Object.hasOwn(parent, property)) projection[property] = parent[property];
+	projection[member] = key;
+	let expanded;
+	try {
+		expanded = await jsonld.expand(structuredClone(projection), {
+			documentLoader: getNormalizationContextLoader(preloadedOnlyDocumentLoader),
+			keepFreeFloatingNodes: true
+		});
+	} catch {
+		return false;
+	}
+	if (expanded.length !== 1 || hasGraphKeyword(expanded)) return false;
+	const node = expanded[0];
+	if (!isJsonMap(node) || typeof node["@id"] !== "string" || getCanonicalPortableIdOf(node["@id"]) !== parentPortableId) return false;
+	const properties = Object.keys(node).filter((property) => property !== "@id" && property !== "@type");
+	if (properties.length !== 1 || properties[0] !== `${SECURITY}${member}`) return false;
+	const values = node[properties[0]];
+	if (!Array.isArray(values) || values.length !== 1) return false;
+	const expandedKey = values[0];
+	if (!isJsonMap(expandedKey) || expandedKey["@id"] !== literalIds[0] || Object.keys(expandedKey).some((property) => !KEY_PROPERTIES.has(property))) return false;
+	const types = expandedKey["@type"];
+	if (types !== void 0 && (!Array.isArray(types) || types.some((type) => typeof type !== "string" || !KEY_TYPES.has(type)))) return false;
+	const pem = expandedKey[`${SECURITY}publicKeyPem`];
+	const multibase = expandedKey[`${SECURITY}publicKeyMultibase`];
+	if (pem === void 0 && multibase === void 0) return false;
+	if (pem !== void 0 && !isSingleStringValue(pem)) return false;
+	if (multibase !== void 0 && !isSingleStringValue(multibase, `${SECURITY}multibase`)) return false;
+	for (const property of [`${SECURITY}owner`, `${SECURITY}controller`]) {
+		const owners = expandedKey[property];
+		if (owners === void 0) continue;
+		if (!Array.isArray(owners) || owners.length !== 1 || !isJsonMap(owners[0]) || Object.keys(owners[0]).length !== 1 || typeof owners[0]["@id"] !== "string" || getCanonicalPortableIdOf(owners[0]["@id"]) !== parentPortableId) return false;
+	}
+	return true;
+}
+function getCanonicalPortableIdOf(id) {
+	try {
+		return getCanonicalPortableId(parseIri(id));
+	} catch (error) {
+		if (error instanceof TypeError) return null;
+		throw error;
+	}
+}
+/**
+* Checks whether an ID is the given portable object's `ap:` or `ap+ef61:`
+* URI, or its compatible identifier, plus a non-empty fragment.  The ID is
+* compared as it is written, so an ID that URL parsing would turn into
+* the portable object's, e.g., through dot segments, is not one of its keys.
+*/
+function isKeyIdOf(id, portableId) {
+	const canonical = getRawCanonicalPortableId(id);
+	if (canonical == null) return false;
+	const hash = canonical.indexOf("#");
+	return hash >= 0 && hash < canonical.length - 1 && canonical.slice(0, hash) === portableId;
+}
+/**
+* Checks whether a `@context` value defines no keyword aliases and no scoped
+* contexts: only references to contexts and term definitions that map terms
+* to IRIs, optionally with an `@id` or `@vocab` type coercion or a datatype.
+*/
+function isSimpleContext(context) {
+	if (typeof context === "string") return true;
+	if (Array.isArray(context)) return context.every(isSimpleContext);
+	if (context === void 0 || !isCompoundProofJsonObject(context)) return false;
+	return Object.entries(context).every(([term, definition]) => {
+		if (term.startsWith("@")) return false;
+		if (typeof definition === "string") return !definition.startsWith("@");
+		if (!isCompoundProofJsonObject(definition)) return false;
+		const { "@id": id, "@type": type, ...rest } = definition;
+		return Object.keys(rest).length < 1 && typeof id === "string" && !id.startsWith("@") && (type === void 0 || type === "@id" || type === "@vocab" || typeof type === "string" && !type.startsWith("@"));
+	});
+}
+function hasGraphKeyword(value) {
+	if (Array.isArray(value)) return value.some(hasGraphKeyword);
+	if (!isJsonMap(value)) return false;
+	return Object.entries(value).some(([key, child]) => key === "@graph" || key === "@included" || key === "@reverse" || hasGraphKeyword(child));
+}
+/**
+* Checks whether expanded values are a single plain string, optionally with
+* the given datatype.
+*/
+function isSingleStringValue(values, datatype) {
+	if (!Array.isArray(values) || values.length !== 1) return false;
+	const value = values[0];
+	if (!isJsonMap(value) || typeof value["@value"] !== "string") return false;
+	const keys = Object.keys(value);
+	return keys.length === 1 || datatype != null && keys.length === 2 && value["@type"] === datatype;
+}
+/**
+* FEP-2277 core types that FEP-ef61 does not require to carry proofs.
+*/
+const UNSECURED_CORE_TYPES = /* @__PURE__ */ new Set([
+	"collection",
+	"link",
+	"verificationMethod",
+	"publicKey"
+]);
+/**
+* Applies the FEP-ef61 proof policy, under the map-local compound-proof
+* profile, to every portable object embedded in a document that a gateway is
+* about to serve, e.g., the items of a portable collection page.  The root
+* map itself is not checked, as the caller built it.
+*
+* Each map below the root whose direct `id` or `@id` is a portable ID or
+* a compatible identifier is checked independently of the others:
+*
+*  -  A map with a direct `proof` is a separately secured document: the proof
+*     has to be a single map, the map has to carry its own `@context`, and
+*     the proof has to verify over the map exactly as it is served, with only
+*     its own proof removed, and be made with a key of the DID in the map's
+*     ID, as the map-local compound-proof profile requires.
+*  -  A map without a proof has to be a collection, a link, or a key, which
+*     FEP-ef61 does not require to be secured.  It is classified under its
+*     effective context, i.e., the `@context` values of its ancestors and
+*     itself, which therefore may only use the simple, preloaded contexts
+*     that the compound-proof policy accepts.
+*
+* Maps that merely refer to a portable object, i.e., have no member other
+* than `id` or `@id`, and maps with non-portable IDs, are neither checked nor
+* verified.  Every `@context` in the document, however, has to be simple, and
+* every portable object that the expanded document describes has to be
+* a map found this way, so that no context can hide a portable object from
+* this check, e.g., by aliasing `@id` or redefining `proof`.  The input must be a finite, already-materialized JSON tree, such
+* as the compact JSON-LD document that is about to be served.
+*
+* @param json The document to check.
+* @param options The options for verifying the proofs.  Proofs whose
+*                verification methods are not `did:key` DID URLs may make
+*                the document loader fetch DID documents.
+* @returns The result, which names the first refused map, if any.
+* @internal
+*/
+async function verifyServedPortableObjects(json, options = {}) {
+	json = JSON.parse(JSON.stringify(json));
+	const collected = collectServedPortableMaps(json);
+	if (!("maps" in collected)) return collected;
+	const maps = collected.maps;
+	const discovered = /* @__PURE__ */ new Map();
+	const ids = maps.map((candidate) => candidate.id);
+	const rootId = isJsonMap(json) ? [json.id, json["@id"]].find(isPortableIdValue) : void 0;
+	if (rootId != null) ids.push(rootId);
+	for (const id of ids) discovered.set(id, (discovered.get(id) ?? 0) + 1);
+	let hidden;
+	try {
+		hidden = findHiddenPortableObject(await jsonld.expand(json, { documentLoader: preloadedOnlyDocumentLoader }), discovered);
+	} catch {
+		return {
+			verified: false,
+			path: "",
+			id: "",
+			reason: "unsupportedContext"
+		};
+	}
+	if (hidden != null) return {
+		verified: false,
+		path: "",
+		id: hidden,
+		reason: "hiddenPortableObject"
+	};
+	for (const candidate of maps) {
+		const reason = await checkServedPortableMap(candidate, options);
+		if (reason != null) return {
+			verified: false,
+			path: candidate.path,
+			id: candidate.id,
+			reason
+		};
+	}
+	return { verified: true };
+}
+/**
+* Finds a portable object that an expanded JSON-LD document describes, i.e.,
+* a node with a portable `@id` and other members, more times than the given
+* numbers of maps found for its ID.
+*/
+function findHiddenPortableObject(expanded, discovered) {
+	const remaining = new Map(discovered);
+	const pending = [expanded];
+	while (pending.length > 0) {
+		const value = pending.pop();
+		if (Array.isArray(value)) {
+			pending.push(...value);
+			continue;
+		}
+		if (!isJsonMap(value)) continue;
+		const id = value["@id"];
+		if (isPortableIdValue(id) && Object.keys(value).some((key) => key !== "@id")) {
+			const count = remaining.get(id) ?? 0;
+			if (count < 1) return id;
+			remaining.set(id, count - 1);
+		}
+		pending.push(...Object.values(value));
+	}
+}
+/**
+* Checks whether a context uses only preloaded remote contexts and simple
+* term definitions, so that the context in effect for a map can be told from
+* the contexts of its ancestors.
+*/
+function isCheckableContext(context) {
+	return (Array.isArray(context) ? context : [context]).every((value) => typeof value === "string" ? Object.hasOwn(preloadedContexts, value) : !Array.isArray(value) && isSimpleContext(value));
+}
+/**
+* Checks whether every remote context that a context refers to is preloaded,
+* so that all of its definitions are known.
+*/
+function hasOnlyPreloadedRemoteContexts(context) {
+	return (Array.isArray(context) ? context : [context]).every((value) => typeof value === "string" ? Object.hasOwn(preloadedContexts, value) : !Array.isArray(value));
+}
+/**
+* Checks whether a map or any map below it, outside proof and context values,
+* has a portable `id` or `@id` and other members.
+*/
+function hasLiteralPortableObject(json) {
+	return findInJsonMaps(json, (map) => [map.id, map["@id"]].some(isPortableIdValue) && Object.keys(map).some((key) => key !== "id" && key !== "@id") ? true : void 0) ?? false;
+}
+function collectServedPortableMaps(json) {
+	const maps = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pending = [{
+		value: json,
+		path: "",
+		depth: 0,
+		contexts: []
+	}];
+	while (pending.length > 0) {
+		const { value, path, depth, contexts } = pending.pop();
+		if (typeof value !== "object" || value == null || seen.has(value)) continue;
+		seen.add(value);
+		if (Array.isArray(value)) {
+			for (let index = value.length - 1; index >= 0; index--) pending.push({
+				value: value[index],
+				path: childPath(path, String(index)),
+				depth: depth + 1,
+				contexts
+			});
+			continue;
+		}
+		const map = value;
+		const hasContext = Object.hasOwn(map, "@context");
+		if (hasContext && !isCheckableContext(map["@context"])) {
+			if (hasOnlyPreloadedRemoteContexts(map["@context"]) && !hasLiteralPortableObject(map)) continue;
+			const id = [map.id, map["@id"]].find((v) => typeof v === "string");
+			return {
+				verified: false,
+				path,
+				id: typeof id === "string" ? id : "",
+				reason: "unsupportedContext"
+			};
+		}
+		const mapContexts = hasContext ? [...contexts, map["@context"]] : contexts;
+		const id = [map.id, map["@id"]].find(isPortableIdValue);
+		if (depth > 0 && id != null && Object.keys(map).some((key) => key !== "id" && key !== "@id")) maps.push({
+			path,
+			id,
+			map,
+			contexts: mapContexts
+		});
+		const keys = Object.keys(map);
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			if (key === "proof" || key === "@context") continue;
+			pending.push({
+				value: map[key],
+				path: childPath(path, key),
+				depth: depth + 1,
+				contexts: mapContexts
+			});
+		}
+	}
+	maps.sort((left, right) => comparePaths(left.path, right.path));
+	return { maps };
+}
+async function checkServedPortableMap({ map, contexts }, options) {
+	if (Object.hasOwn(map, "proof")) {
+		if (!isJsonMap(map.proof)) return "unsupportedProofShape";
+		if (!Object.hasOwn(map, "@context")) return "missingContext";
+		try {
+			const policy = await verifyPortableObjectProofPolicy(map, await verifyMapLocalProof(map, options), options);
+			return policy.verified ? null : policy.reason.type;
+		} catch (error) {
+			if (error instanceof TypeError) return "invalidPortableObject";
+			throw error;
+		}
+	}
+	const flattened = contexts.flatMap((context) => Array.isArray(context) ? context : [context]);
+	if (flattened.length < 1 || !isSimpleContext(flattened)) return "unsupportedContext";
+	let expanded;
+	try {
+		expanded = await jsonld.expand({
+			...map,
+			"@context": flattened
+		}, { documentLoader: preloadedOnlyDocumentLoader });
+	} catch {
+		return "unsupportedContext";
+	}
+	if (expanded.length !== 1 || !isJsonMap(expanded[0])) return "invalidPortableObject";
+	const type = classifyFep2277CoreType(expanded[0]);
+	return UNSECURED_CORE_TYPES.has(type) ? null : "missingProof";
+}
+//#endregion
+export { inspectCompoundPortableObjectApplicability as a, verifyServedPortableObjects as c, findUnsupportedCompoundProofShape as i, discoverCompoundProofDocuments as n, verifyCompoundPortableObjectProofs as o, findEmbeddedProofWithoutContext as r, verifyCompoundProofDocuments as s, containsCompoundPortableObject as t };