@fedify/fedify 2.4.0-dev.2141 → 2.4.0-dev.2155

package/dist/{builder-BI7H61zO.mjs → builder-CxHALSwA.mjs}

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-BXI_BLNy.mjs";
-import { c as isPortableId } from "./portable-key-id-Bg259c4Z.mjs";
+import { n as version, t as name } from "./deno-YLLbRq06.mjs";
+import { c as isPortableId, r as getPortableDid, t as getCanonicalPortableId } from "./portable-key-id-Bg259c4Z.mjs";
 import { t as ActivityListenerSet } from "./activity-listener-C-BSbKI7.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Router, RouterError, assertPath } from "@fedify/uri-template";
@@ -89,7 +89,7 @@ var FederationBuilderImpl = class {
 	* specified.
 	*/
 	async build(options) {
-		const { FederationImpl } = await import("./middleware-B7stx5gy.mjs");
+		const { FederationImpl } = await import("./middleware-BahNnLfD.mjs");
 		const f = new FederationImpl(options);
 		const trailingSlashInsensitiveValue = f.router.trailingSlashInsensitive;
 		f.router = this.router.clone();
@@ -166,6 +166,7 @@ var FederationBuilderImpl = class {
 			else if (!portable && actor.id.href != context.getActorUri(identifier).href) logger.warn("Actor dispatcher returned an actor with an id property that does not match the actor URI.  Set the property with Context.getActorUri(identifier).");
 			if (actor instanceof Tombstone) return actor;
 			if (actor.id != null && isCompatibleEf61Iri(actor.id)) warnCompatibleActorId(actor.id, actor.gateway);
+			if (portable) this.#warnPortableCollectionIds(context, identifier, actor);
 			if (this.followingCallbacks != null && this.followingCallbacks.dispatcher != null) {
 				if (actor.followingId == null) logger.warn("You configured a following collection dispatcher, but the actor does not have a following property.  Set the property with Context.getFollowingUri(identifier).");
 				else if (!portable && actor.followingId.href != context.getFollowingUri(identifier).href) logger.warn("You configured a following collection dispatcher, but the actor's following property does not match the following collection URI.  Set the property with Context.getFollowingUri(identifier).");
@@ -651,6 +652,10 @@ var FederationBuilderImpl = class {
 			authorize(predicate) {
 				callbacks.authorizePredicate = predicate;
 				return setters;
+			},
+			mapPortableOwner(mapper) {
+				callbacks.portableOwnerMapper = mapper;
+				return setters;
 			}
 		};
 		return setters;
@@ -672,6 +677,54 @@ var FederationBuilderImpl = class {
 		this.outboxPermanentFailureHandler = handler;
 	}
 	/**
+	* Warns if a portable actor's collection properties that are portable IDs
+	* or compatible identifiers do not refer to the collections that
+	* the registered collection dispatchers serve through the FEP-ef61 gateway
+	* endpoint for the actor's DID.  Properties with ordinary HTTP(S) URLs are
+	* not compared, since a portable actor may keep ordinary collections.
+	*/
+	#warnPortableCollectionIds(context, identifier, actor) {
+		const did = actor.id == null ? null : getPortableDid(actor.id);
+		if (did == null) return;
+		const logger = getLogger([
+			"fedify",
+			"federation",
+			"actor"
+		]);
+		const check = (registered, property, value, helper, build) => {
+			if (!registered || value == null || !isPortableId(value)) return;
+			const actual = getCanonicalPortableId(value);
+			if (actual == null) {
+				logger.warn("The actor's {property} property, {value}, is a malformed FEP-ef61 portable ID or compatible identifier.", {
+					property,
+					value: value.href
+				});
+				return;
+			}
+			let expected;
+			try {
+				expected = build();
+			} catch (error) {
+				if (error instanceof TypeError || error instanceof RouterError) return;
+				throw error;
+			}
+			if (actual === getCanonicalPortableId(expected)) return;
+			logger.warn("The portable actor's {property} property, {value}, does not match the portable ID of the collection that the gateway endpoint serves, {expected}.  Set the property with Context.{helper}(identifier, did).", {
+				property,
+				value: value.href,
+				expected: expected.href,
+				helper
+			});
+		};
+		check(this.outboxCallbacks?.dispatcher != null, "outbox", actor.outboxId, "getPortableOutboxUri", () => context.getPortableOutboxUri(identifier, did));
+		check(this.inboxCallbacks?.dispatcher != null || this.router.has("inbox"), "inbox", actor.inboxId, "getPortableInboxUri", () => context.getPortableInboxUri(identifier, did));
+		check(this.followingCallbacks?.dispatcher != null, "following", actor.followingId, "getPortableFollowingUri", () => context.getPortableFollowingUri(identifier, did));
+		check(this.followersCallbacks?.dispatcher != null, "followers", actor.followersId, "getPortableFollowersUri", () => context.getPortableFollowersUri(identifier, did));
+		check(this.likedCallbacks?.dispatcher != null, "liked", actor.likedId, "getPortableLikedUri", () => context.getPortableLikedUri(identifier, did));
+		check(this.featuredCallbacks?.dispatcher != null, "featured", actor.featuredId, "getPortableFeaturedUri", () => context.getPortableFeaturedUri(identifier, did));
+		check(this.featuredTagsCallbacks?.dispatcher != null, "featuredTags", actor.featuredTagsId, "getPortableFeaturedTagsUri", () => context.getPortableFeaturedTagsUri(identifier, did));
+	}
+	/**
 	* Converts a name (string or symbol) to a unique string identifier.
 	* For symbols, generates and caches a UUID if not already present.
 	* For strings, returns the string as-is.

package/dist/compat/mod.d.cts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Zt as ActivityTransformer, n as Context } from "../context-CrDDVrbF.cjs";
+import { Qt as ActivityTransformer, n as Context } from "../context-BMggDR-l.cjs";
 import { Activity } from "@fedify/vocab";
 
 //#region src/compat/transformers.d.ts

package/dist/compat/mod.d.ts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { Zt as ActivityTransformer, n as Context } from "../context-B2C8nuN3.js";
+import { Qt as ActivityTransformer, n as Context } from "../context-exYu7gDU.js";
 import { Activity } from "@fedify/vocab";
 
 //#region src/compat/transformers.d.ts

package/dist/compat/transformers.test.mjs

@@ -5,7 +5,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { E as autoIdAssigner, T as actorDehydrator, n as FederationImpl } from "../middleware-CAWRGSwH.mjs";
+import { E as autoIdAssigner, T as actorDehydrator, n as FederationImpl } from "../middleware-DDa8pCUa.mjs";
 import { Follow, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/compat/transformers.test.ts

package/dist/{compound-proof-D0H4LLvQ.mjs → compound-proof-nhrXTRQO.mjs}

@@ -3,9 +3,9 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { c as isPortableId, i as getRawCanonicalPortableId, t as getCanonicalPortableId } from "./portable-key-id-Bg259c4Z.mjs";
 import { n as preloadedOnlyDocumentLoader } from "./public-audience--klBIOk1.mjs";
-import { c as getNormalizationContextLoader } from "./ld-CWDReGMZ.mjs";
-import { a as verifyMapLocalProof, c as verifyPortableObjectProofPolicy } from "./proof-B5s-W6Sm.mjs";
-import { parseIri } from "@fedify/vocab-runtime";
+import { c as getNormalizationContextLoader } from "./ld-Djxsq6JR.mjs";
+import { l as verifyPortableObjectProofPolicy, n as classifyFep2277CoreType, o as verifyMapLocalProof } from "./proof-vZ04IAjq.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();
@@ -736,5 +736,217 @@ function isSingleStringValue(values, datatype) {
 	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 { verifyCompoundPortableObjectProofs as a, inspectCompoundPortableObjectApplicability as i, discoverCompoundProofDocuments as n, verifyCompoundProofDocuments as o, findUnsupportedCompoundProofShape as r, containsCompoundPortableObject as t };
+export { verifyCompoundPortableObjectProofs as a, inspectCompoundPortableObjectApplicability as i, discoverCompoundProofDocuments as n, verifyCompoundProofDocuments as o, findUnsupportedCompoundProofShape as r, verifyServedPortableObjects as s, containsCompoundPortableObject as t };