@fedify/fedify 2.4.0-dev.2115 → 2.4.0-dev.2127

package/dist/sig/portable-collection.test.mjs

@@ -1,427 +1,16 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "../deno-CCABdw7r.mjs";
-import { l as verifyPortableObjectProofWithRoot, s as verifyPortableObjectProof } from "../proof-xdPYGPaA.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { getLogger } from "@logtape/logtape";
-import { Collection, CollectionPage, Note, Object as Object$1, OrderedCollection, Person, isActor, traverseCollection } from "@fedify/vocab";
-import { trace } from "@opentelemetry/api";
+import { t as verifyPortableObject } from "../portable-collection-WXaHkNqC.mjs";
+import { Collection, CollectionPage, Note, OrderedCollection, Person, traverseCollection } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
-import { FetchError, canonicalizePortableUri, encodeMultibase, exportDidKey, formatIri, fromCompatibleEf61Id, getDocumentLoader, getFe34Origin, parseIri, preloadedContexts } from "@fedify/vocab-runtime";
-import { dereferencePortableIri, getPortableGatewayCandidates } from "@fedify/vocab-runtime/internal/portable-dereference";
+import { FetchError, encodeMultibase, exportDidKey, preloadedContexts } from "@fedify/vocab-runtime";
 import serialize from "json-canon";
 import { deepStrictEqual, ok, strictEqual } from "node:assert/strict";
-//#region src/sig/portable-collection.ts
-const logger = getLogger([
-	"fedify",
-	"sig",
-	"proof"
-]);
-const AS_NAMESPACE = "https://www.w3.org/ns/activitystreams#";
-const AS_ATTRIBUTED_TO = `${AS_NAMESPACE}attributedTo`;
-const AS_PART_OF = `${AS_NAMESPACE}partOf`;
-/**
-* The properties through which a collection refers to its pages, and a page
-* to other pages of the same collection.
-*/
-const PAGING_PROPERTIES = new Set([
-	"first",
-	"last",
-	"current",
-	"next",
-	"prev"
-].map((p) => AS_NAMESPACE + p));
-/**
-* The properties through which an actor refers to its own collections.
-*/
-const ACTOR_COLLECTION_PROPERTIES = /* @__PURE__ */ new Set([
-	"http://www.w3.org/ns/ldp#inbox",
-	`${AS_NAMESPACE}outbox`,
-	`${AS_NAMESPACE}followers`,
-	`${AS_NAMESPACE}following`,
-	`${AS_NAMESPACE}liked`
-]);
-const contextStates = /* @__PURE__ */ new WeakMap();
-function createContext(state) {
-	const token = Object.freeze(Object.create(null));
-	contextStates.set(token, state);
-	return token;
-}
-function getContextState(context) {
-	if (context == null || typeof context !== "object") return void 0;
-	return contextStates.get(context);
-}
-function canonicalize(id) {
-	try {
-		const portable = fromCompatibleEf61Id(id);
-		if (portable != null) return canonicalizePortableUri(formatIri(portable));
-		return canonicalizePortableUri(typeof id === "string" ? id : formatIri(id));
-	} catch (error) {
-		if (error instanceof TypeError) return null;
-		throw error;
-	}
-}
-function toUrl(canonicalId) {
-	return parseIri(canonicalId);
-}
-function canonicalizeAll(ids) {
-	const result = [];
-	for (const id of ids) {
-		const canonical = canonicalize(id);
-		if (canonical == null) return null;
-		result.push(canonical);
-	}
-	return result;
-}
-function getExpandedIds(node, property) {
-	const values = node[property];
-	if (values == null) return [];
-	if (!Array.isArray(values)) return null;
-	const ids = [];
-	for (const value of values) {
-		if (value == null || typeof value !== "object" || Array.isArray(value) || typeof value["@id"] !== "string") return null;
-		ids.push(value["@id"]);
-	}
-	return ids;
-}
-function parseAll(ids) {
-	const result = [];
-	for (const id of ids) try {
-		result.push(parseIri(id));
-	} catch (error) {
-		if (error instanceof TypeError) return null;
-		throw error;
-	}
-	return result;
-}
-function describeRoot(root) {
-	const rawId = root["@id"];
-	if (typeof rawId !== "string") return null;
-	const id = canonicalize(rawId);
-	if (id == null) return null;
-	const partOf = getExpandedIds(root, AS_PART_OF);
-	const attributedTo = getExpandedIds(root, AS_ATTRIBUTED_TO);
-	return {
-		id,
-		url: toUrl(id),
-		origin: getFe34Origin(id),
-		partOf: partOf == null ? null : canonicalizeAll(partOf),
-		attributedTo: attributedTo == null ? null : canonicalizeAll(attributedTo),
-		attributedToUrls: attributedTo == null ? null : parseAll(attributedTo)
-	};
-}
-function describeObject(object) {
-	if (!(object instanceof Object$1) || object.id == null) return null;
-	const id = canonicalize(object.id);
-	if (id == null) return null;
-	const partOfId = object instanceof CollectionPage ? object.partOfId : null;
-	return {
-		id,
-		url: toUrl(id),
-		origin: getFe34Origin(id),
-		partOf: canonicalizeAll(partOfId == null ? [] : [partOfId]),
-		attributedTo: canonicalizeAll(object.attributionIds),
-		attributedToUrls: object.attributionIds
-	};
-}
-function fail(reason) {
-	return {
-		verified: false,
-		reason
-	};
-}
-/**
-* Walks the referrer chain of a collection or page to find the root
-* collection and its owner candidate, checking every page on the way.
-*/
-function resolveChain(node, referrer) {
-	const pages = [];
-	let top = node;
-	let link = referrer;
-	let state;
-	while (link != null && PAGING_PROPERTIES.has(link.property)) {
-		pages.push(top);
-		state = getContextState(link.collectionContext);
-		if (state != null) break;
-		const parent = describeObject(link.object);
-		if (parent == null || link.truncated) return fail({ type: "unknownCollectionOwner" });
-		top = parent;
-		link = link.referrer;
-	}
-	let rootId;
-	let rootOrigin;
-	let candidate;
-	if (state != null) {
-		rootId = state.rootId;
-		rootOrigin = state.rootOrigin;
-		const ownerCandidate = state.owner == null ? state.ownerCandidate : { id: canonicalize(state.owner.id) };
-		if (ownerCandidate == null) return fail({ type: "unknownCollectionOwner" });
-		candidate = ownerCandidate;
-	} else {
-		rootId = top.id;
-		rootOrigin = top.origin;
-		const attributedTo = top.attributedTo;
-		if (attributedTo == null) return fail({ type: "unknownCollectionOwner" });
-		if (link != null && ACTOR_COLLECTION_PROPERTIES.has(link.property)) {
-			const id = link.id == null ? null : canonicalize(link.id);
-			if (id == null) return fail({ type: "unknownCollectionOwner" });
-			candidate = {
-				id,
-				object: link.object,
-				acceptance: link.acceptance
-			};
-		} else if (attributedTo.length === 1) candidate = {
-			id: attributedTo[0],
-			url: top.attributedToUrls?.[0]
-		};
-		else if (attributedTo.length > 1) return fail({
-			type: "conflictingCollectionOwners",
-			candidates: attributedTo.map(toUrl)
-		});
-		else return fail({ type: "unknownCollectionOwner" });
-		const conflict = attributedTo.find((id) => id !== candidate.id);
-		if (conflict != null) return fail({
-			type: "conflictingCollectionOwners",
-			candidates: [toUrl(candidate.id), toUrl(conflict)]
-		});
-	}
-	if (getFe34Origin(candidate.id) !== rootOrigin) return fail({ type: "unknownCollectionOwner" });
-	for (const page of pages) {
-		if (page.origin !== rootOrigin) return fail({
-			type: "collectionPageMismatch",
-			pageId: page.url,
-			collectionId: toUrl(rootId),
-			partOf: null
-		});
-		if (page.partOf == null) return fail({ type: "unknownCollectionOwner" });
-		const partOf = page.partOf.find((id) => id !== rootId);
-		if (partOf != null) return fail({
-			type: "collectionPageMismatch",
-			pageId: page.url,
-			collectionId: toUrl(rootId),
-			partOf: toUrl(partOf)
-		});
-		if (page.attributedTo == null) return fail({ type: "unknownCollectionOwner" });
-		const conflict = page.attributedTo.find((id) => id !== candidate.id);
-		if (conflict != null) return fail({
-			type: "conflictingCollectionOwners",
-			candidates: [toUrl(candidate.id), toUrl(conflict)]
-		});
-	}
-	return {
-		rootId,
-		rootOrigin,
-		owner: state?.owner ?? null,
-		candidate
-	};
-}
-function getActorCollectionIds(actor) {
-	const ids = [];
-	for (const id of [
-		actor.inboxId,
-		actor.outboxId,
-		actor.followersId,
-		actor.followingId,
-		actor.likedId
-	]) {
-		if (id == null) continue;
-		const canonical = canonicalize(id);
-		if (canonical != null) ids.push(canonical);
-	}
-	return ids;
-}
-async function fetchOwner(candidate, options) {
-	const documentLoader = options.documentLoader ?? getDocumentLoader();
-	const contextLoader = options.contextLoader ?? getDocumentLoader();
-	const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
-	const tracer = tracerProvider.getTracer(name, version);
-	let inferredGateways;
-	try {
-		const portable = fromCompatibleEf61Id(candidate);
-		if (portable != null) {
-			inferredGateways = [new URL(candidate.origin)];
-			candidate = portable;
-		}
-	} catch (error) {
-		if (!(error instanceof TypeError)) throw error;
-		logger.debug("The owner {owner} of a portable collection is a malformed compatible identifier.", { owner: candidate.href });
-		return null;
-	}
-	const gateways = options.gateways ?? (inferredGateways != null || getPortableGatewayCandidates(candidate).length > 0 ? void 0 : options.gatewayHints);
-	if (options.gateways != null) inferredGateways = void 0;
-	const span = tracer.startSpan("activitypub.lookup_object");
-	try {
-		const object = await dereferencePortableIri(candidate, {
-			documentLoader,
-			contextLoader,
-			tracerProvider,
-			gateways,
-			...inferredGateways == null ? {} : { inferredGateways },
-			verifyPortableObject: (document, verifierOptions) => verifyPortableObjectProof(document, {
-				...options,
-				...verifierOptions
-			}),
-			suppressError: true,
-			span,
-			parse: (document, parseOptions) => Object$1.fromJsonLd(document, {
-				documentLoader,
-				contextLoader: parseOptions.contextLoader,
-				tracerProvider,
-				baseUrl: parseOptions.baseUrl
-			})
-		});
-		return isActor(object) ? object : null;
-	} catch (error) {
-		logger.debug("Failed to fetch the owner {owner} of a portable collection: {error}", {
-			owner: formatIri(candidate),
-			error
-		});
-		return null;
-	} finally {
-		span.end();
-	}
-}
-async function resolveOwner(chain, options) {
-	if (chain.owner != null) return chain.owner;
-	const { candidate } = chain;
-	const candidateUrl = toUrl(candidate.id);
-	let actor = null;
-	if (candidate.acceptance === "verified" && isActor(candidate.object) && candidate.object.id != null && canonicalize(candidate.object.id) === candidate.id) actor = candidate.object;
-	else actor = await fetchOwner(candidate.url ?? (candidate.object instanceof Object$1 && candidate.object.id != null ? candidate.object.id : candidateUrl), options);
-	if (actor == null || actor.id == null) return fail({
-		type: "collectionOwnerUnavailable",
-		owner: candidateUrl
-	});
-	const gateways = actor.gateways;
-	if (gateways.length < 1) return fail({
-		type: "collectionOwnerUnavailable",
-		owner: candidateUrl
-	});
-	if (!getActorCollectionIds(actor).includes(chain.rootId)) return fail({
-		type: "collectionNotListedByOwner",
-		owner: candidateUrl,
-		collectionId: toUrl(chain.rootId)
-	});
-	return {
-		id: candidateUrl,
-		gateways
-	};
-}
-function getSourceGateway(node, documentUrl) {
-	if (documentUrl == null || documentUrl.protocol !== "http:" && documentUrl.protocol !== "https:") return null;
-	let portableId;
-	try {
-		portableId = fromCompatibleEf61Id(documentUrl);
-	} catch (error) {
-		if (error instanceof TypeError) return null;
-		throw error;
-	}
-	if (portableId == null || canonicalize(portableId) !== node.id) return null;
-	return new URL(documentUrl.origin);
-}
-/**
-* Applies the [FEP-ef61] trust policy to a portable object fetched through
-* a gateway.
-*
-* Portable actors, activities, objects, and collections with proofs are
-* verified by {@link verifyPortableObjectProof}.  A portable collection or
-* collection page without a proof is accepted only if all of the following
-* hold:
-*
-*  -  It was retrieved from a gateway: its final URL (`documentUrl`) is
-*     a compatible identifier for the same portable collection.
-*  -  Its owner is determined unambiguously: the actor whose `inbox`,
-*     `outbox`, `followers`, `following`, or `liked` property referred to
-*     the collection, or the single actor in its `attributedTo`.  A page
-*     inherits the owner of the collection it was reached from through
-*     `first`, `last`, `current`, `next`, or `prev`, and must not name
-*     another collection in `partOf`.
-*  -  The owner's actor document is verified by its proof and lists the
-*     collection as its `inbox`, `outbox`, `followers`, `following`, or
-*     `liked`.
-*  -  The gateway that served the collection is in the owner's `gateways`.
-*
-* Where the document came from and which object referred to it are passed
-* by property accessors when this function is used as their
-* `verifyPortableObject` option.  Objects embedded in an unsecured
-* collection accepted this way are not trusted: accessors dereference and
-* verify them one by one.
-*
-* Note that acceptance through the gateway policy does not verify anything
-* cryptographically; it only means that the owner trusts the gateway.
-*
-* [FEP-ef61]: https://w3id.org/fep/ef61
-*
-* @param jsonLd The JSON-LD document to verify.
-* @param options Additional options.  See also
-*                {@link VerifyPortableObjectOptions}.
-* @returns The detailed 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 verifyPortableObject(jsonLd, options = {}) {
-	const { result, root, objectType } = await verifyPortableObjectProofWithRoot(jsonLd, options);
-	if (result.verified) {
-		const node = objectType === "collection" && root != null ? describeRoot(root) : null;
-		const chain = node == null ? null : resolveChain(node, options.referrer);
-		if (chain == null || !("rootId" in chain)) return {
-			verified: true,
-			method: "proof",
-			keys: result.keys
-		};
-		return {
-			verified: true,
-			method: "proof",
-			keys: result.keys,
-			collectionContext: createContext({
-				rootId: chain.rootId,
-				rootOrigin: chain.rootOrigin,
-				owner: chain.owner,
-				ownerCandidate: chain.candidate
-			})
-		};
-	}
-	if (result.reason.type !== "unsecuredCollection") return {
-		verified: false,
-		reason: result.reason
-	};
-	const node = root == null ? null : describeRoot(root);
-	if (node == null) return fail({ type: "unknownCollectionOwner" });
-	const gateway = getSourceGateway(node, options.documentUrl);
-	if (gateway == null) return fail({
-		type: "unknownCollectionSource",
-		documentUrl: options.documentUrl ?? null
-	});
-	const chain = resolveChain(node, options.referrer);
-	if (!("rootId" in chain)) return chain;
-	const owner = await resolveOwner(chain, options);
-	if (!("gateways" in owner)) return owner;
-	if (!owner.gateways.some((g) => g.origin === gateway.origin)) return fail({
-		type: "untrustedGateway",
-		owner: owner.id,
-		gateway,
-		gateways: owner.gateways
-	});
-	return {
-		verified: true,
-		method: "gateway",
-		unsecured: true,
-		owner: owner.id,
-		gateway,
-		collectionContext: createContext({
-			rootId: chain.rootId,
-			rootOrigin: chain.rootOrigin,
-			owner,
-			ownerCandidate: null
-		})
-	};
-}
-//#endregion
 //#region src/sig/portable-collection.test.ts
 const AS = "https://www.w3.org/ns/activitystreams#";
-const context$1 = [
+const context = [
 	"https://www.w3.org/ns/activitystreams",
 	"https://w3id.org/security/data-integrity/v1",
 	"https://w3id.org/fep/ef61"
@@ -464,7 +53,7 @@ async function sign(document, privateKey = ed25519PrivateKey, verificationMethod
 }
 function actor(overrides = {}) {
 	return {
-		"@context": context$1,
+		"@context": context,
 		id: actorId,
 		type: "Person",
 		inbox: `ap://${did}/actor/inbox`,
@@ -476,7 +65,7 @@ function actor(overrides = {}) {
 }
 function outbox(overrides = {}) {
 	return {
-		"@context": context$1,
+		"@context": context,
 		id: outboxId,
 		type: "OrderedCollection",
 		totalItems: 0,
@@ -648,7 +237,7 @@ test("verifyPortableObject() requires an unambiguous owner", async () => {
 	};
 	assertFailure(await verify(outbox(), base), "unknownCollectionOwner");
 	const note = await Note.fromJsonLd({
-		"@context": context$1,
+		"@context": context,
 		id: `ap://${did}/notes/1`,
 		type: "Note"
 	}, { contextLoader });
@@ -772,7 +361,7 @@ test("verifyPortableObject() checks pages against their collection", async () =>
 	const collectionContext = collectionResult.collectionContext;
 	const pageId = `ap://${did}/actor/outbox?page=1`;
 	const page = (overrides = {}) => ({
-		"@context": context$1,
+		"@context": context,
 		id: pageId,
 		type: "OrderedCollectionPage",
 		partOf: outboxId,
@@ -831,14 +420,14 @@ test("verifyPortableObject() checks intermediate pages", async () => {
 	const documentLoader = createLoader({ [gatewayUrl(gw1, actorId)]: signedActor });
 	const collection = await OrderedCollection.fromJsonLd(outbox(), { contextLoader });
 	const intermediate = async (partOf) => await CollectionPage.fromJsonLd({
-		"@context": context$1,
+		"@context": context,
 		id: `ap://${did}/actor/outbox?page=1`,
 		type: "OrderedCollectionPage",
 		partOf
 	}, { contextLoader });
 	const pageId = `ap://${did}/actor/outbox?page=2`;
 	const page = {
-		"@context": context$1,
+		"@context": context,
 		id: pageId,
 		type: "OrderedCollectionPage",
 		partOf: outboxId,
@@ -868,7 +457,7 @@ test("verifyPortableObject() checks intermediate pages", async () => {
 test("verifyPortableObject() works with property accessors", async () => {
 	const itemId = `ap://${did}/notes/1`;
 	const note = await sign({
-		"@context": context$1,
+		"@context": context,
 		id: itemId,
 		type: "Note",
 		attributedTo: actorId,
@@ -892,11 +481,11 @@ test("verifyPortableObject() works with property accessors", async () => {
 			[gatewayUrl(gw1, actorId)]: signedActor,
 			[gatewayUrl(gw1, outboxId)]: outbox({ first: page1 }),
 			[gatewayUrl(gw1, page1Id)]: {
-				"@context": context$1,
+				"@context": context,
 				...page1
 			},
 			[gatewayUrl(gw1, page2Id)]: {
-				"@context": context$1,
+				"@context": context,
 				id: page2Id,
 				type: "OrderedCollectionPage",
 				partOf: outboxId,
@@ -909,7 +498,7 @@ test("verifyPortableObject() works with property accessors", async () => {
 		verifyPortableObject
 	};
 	const create = await Collection.fromJsonLd({
-		"@context": context$1,
+		"@context": context,
 		type: "Collection",
 		items: [actorId]
 	}, { contextLoader });
@@ -932,7 +521,7 @@ test("verifyPortableObject() works with property accessors", async () => {
 test("verifyPortableObject() lets pages inherit owners across signed and embedded collections", async () => {
 	const page1Id = `ap://${did}/actor/outbox?page=1`;
 	const page1 = {
-		"@context": context$1,
+		"@context": context,
 		id: page1Id,
 		type: "OrderedCollectionPage",
 		partOf: outboxId,
@@ -940,7 +529,7 @@ test("verifyPortableObject() lets pages inherit owners across signed and embedde
 	};
 	const fetchPerson = async (options) => {
 		const wrapper = await Collection.fromJsonLd({
-			"@context": context$1,
+			"@context": context,
 			type: "Collection",
 			items: [actorId]
 		}, { contextLoader });
@@ -1006,7 +595,7 @@ test("verifyPortableObject() reuses a verified actor for pages of signed collect
 	const collection = await OrderedCollection.fromJsonLd(outbox(), { contextLoader });
 	const pageId = `ap://${did}/actor/outbox?page=1`;
 	const result = await verify({
-		"@context": context$1,
+		"@context": context,
 		id: pageId,
 		type: "OrderedCollectionPage",
 		partOf: outboxId,
@@ -1034,21 +623,21 @@ test("verifyPortableObject() fetches the owner through attributedTo hints", asyn
 test("verifyPortableObject() applies to compatible identifiers in accessors", async (t) => {
 	const noteId = `ap://${did}/notes/1`;
 	const signedNote = await sign({
-		"@context": context$1,
+		"@context": context,
 		id: noteId,
 		type: "Note",
 		attributedTo: actorId,
 		content: "Hello"
 	});
 	const forgedNote = {
-		"@context": context$1,
+		"@context": context,
 		id: noteId,
 		type: "Note",
 		attributedTo: actorId,
 		content: "Forged"
 	};
 	const collection = (items) => Collection.fromJsonLd({
-		"@context": context$1,
+		"@context": context,
 		id: "https://example.com/collection",
 		type: "Collection",
 		items

package/dist/sig/portable-key.test.mjs

@@ -2,12 +2,12 @@ import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
-import { i as fetchKey } from "../key-CkNxztNV.mjs";
-import { h as verifyJsonLd, p as signJsonLd } from "../ld-CnT0f1nU.mjs";
-import { n as createProof, u as verifyProof } from "../proof-xdPYGPaA.mjs";
-import { d as verifyRequest, f as verifyRequestDetailed, l as signRequest } from "../http-BcLnr2do.mjs";
+import { i as fetchKey } from "../key-Cc1b6pW9.mjs";
+import { h as verifyJsonLd, p as signJsonLd } from "../ld-DQNTIrAe.mjs";
+import { n as createProof, u as verifyProof } from "../proof-CW8k0R1G.mjs";
+import { d as verifyRequest, f as verifyRequestDetailed, l as signRequest } from "../http-BFeK9sBg.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-9LiHmOv1.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-CCfdL83M.mjs";
 import { t as KvKeyCache } from "../keycache-BInaECGj.mjs";
 import { Create, CryptographicKey, Multikey, Note, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";

package/dist/sig/proof.test.mjs

@@ -10,10 +10,10 @@ import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
-import { i as signObject, n as createProof, o as verifyObject, r as hasProofLike, s as verifyPortableObjectProof, u as verifyProof } from "../proof-xdPYGPaA.mjs";
-import { d as verifyRequest } from "../http-BcLnr2do.mjs";
+import { i as signObject, n as createProof, o as verifyObject, r as hasProofLike, s as verifyPortableObjectProof, u as verifyProof } from "../proof-CW8k0R1G.mjs";
+import { d as verifyRequest } from "../http-BFeK9sBg.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-Bby5g2iu.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-Dtuyb0ps.mjs";
 import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place, Translation } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { decodeMultibase, encodeMultibase, exportDidKey, exportMultibaseKey, formatIri, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";

package/dist/{temporal-tAtwv6vX.mjs → temporal-CffY_XOJ.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { c as getNormalizationContextLoader } from "./ld-CnT0f1nU.mjs";
+import { c as getNormalizationContextLoader } from "./ld-DQNTIrAe.mjs";
 import jsonld from "@fedify/vocab-runtime/jsonld";
 //#region src/federation/temporal.ts
 function isPlainObject(value) {

package/dist/testing/kv.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { n as baseOptions, o as stringSchema, t as MockQueue } from "../tasks-dbCShlCb.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
-import { o as createFederation } from "../middleware-BpwKvOpU.mjs";
+import { o as createFederation } from "../middleware-BdhvduR9.mjs";
 //#region src/testing/kv.test.ts
 test("ManualClockKvStore keeps an entry at its exact expiration instant", async () => {
 	const kv = new ManualClockKvStore();

package/dist/testing/mod.d.mts

@@ -5,7 +5,7 @@ import { Router } from "@fedify/uri-template";
 import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Note, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
 import { MeterProvider, TracerProvider } from "@opentelemetry/api";
-import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions } from "@fedify/vocab-runtime";
+import { AuthenticatedDocumentLoaderFactory, DocumentLoader, DocumentLoaderFactory, GetUserAgentOptions, PortableObjectVerifier } from "@fedify/vocab-runtime";
 import { MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -2881,6 +2881,27 @@ interface Context<TContextData> {
    * The context loader for loading remote JSON-LD contexts.
    */
   readonly contextLoader: DocumentLoader;
+  /**
+   * The [FEP-ef61] portable object policy that this context applies to
+   * portable objects it dereferences.  It is `verifyPortableObject()` with
+   * this context's document loader, context loader, and tracer provider as
+   * defaults, which the options passed to it override.
+   *
+   * Since its name is the same as the `verifyPortableObject` option of
+   * property accessors, `lookupObject()`, and `traverseCollection()`, passing
+   * a context as their options applies the policy, e.g.,
+   * `await create.getObject(ctx)`.  Objects parsed with a context as options,
+   * such as activities that inboxes receive, also use it by default for
+   * their property accessors.  It never verifies an object by itself being
+   * there: it only applies to objects that are dereferenced.
+   *
+   * It is optional only so that custom implementations of this interface
+   * keep working; contexts that Fedify creates always have it.
+   *
+   * [FEP-ef61]: https://w3id.org/fep/ef61
+   * @since 2.4.0
+   */
+  readonly verifyPortableObject?: PortableObjectVerifier;
   /**
    * The federation object that this context belongs to.
    * @since 1.6.0
@@ -3158,10 +3179,13 @@ interface Context<TContextData> {
    *
    * It's almost the same as the {@link lookupObject} function, but it uses
    * the context's document loader and context loader by default.  It also
-   * uses `verifyPortableObjectProof()` as the `verifyPortableObject`
+   * uses {@link Context.verifyPortableObject} as the `verifyPortableObject`
    * option by default (since 2.4.0), so [FEP-ef61] portable objects,
    * including portable actors found through WebFinger, are looked up through
-   * their gateways and returned only if they have valid proofs.
+   * their gateways and returned only if they have valid proofs, or, for
+   * collections without proofs, if they are served by gateways that their
+   * owners list.  The returned object uses the same policy by default for
+   * its property accessors.
    *
    * [FEP-ef61]: https://w3id.org/fep/ef61
    *
@@ -3187,7 +3211,9 @@ interface Context<TContextData> {
    * ```
    *
    * It's almost the same as the {@link traverseCollection} function, but it
-   * uses the context's document loader and context loader by default.
+   * uses the context's document loader and context loader by default.  It
+   * also uses {@link Context.verifyPortableObject} as the
+   * `verifyPortableObject` option by default (since 2.4.0).
    * @param collection The collection to traverse.
    * @param options Options for traversing the collection.
    * @returns An async iterable of each item in the collection.