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

package/dist/{public-audience-Cr5MsnMq.mjs → public-audience--klBIOk1.mjs}

@@ -1,6 +1,7 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
+import { t as isSelfContainedSecuredDocument } from "./secured-document-CxzZZ9nL.mjs";
 import { getLogger } from "@logtape/logtape";
 import { PUBLIC_COLLECTION } from "@fedify/vocab";
 import { preloadedContexts } from "@fedify/vocab-runtime";
@@ -30,7 +31,7 @@ const logger = getLogger([
 	"compat",
 	"public-audience"
 ]);
-const PUBLIC_ADDRESSING_FIELDS = new Set([
+const PUBLIC_ADDRESSING_FIELDS = /* @__PURE__ */ new Set([
 	"to",
 	"cc",
 	"bto",
@@ -40,36 +41,39 @@ const PUBLIC_ADDRESSING_FIELDS = new Set([
 const AS_CONTEXT_URL = "https://www.w3.org/ns/activitystreams";
 const MAX_TRAVERSAL_DEPTH = 64;
 const KNOWN_SAFE_CONTEXT_URLS = new Set(Object.keys(preloadedContexts));
-function hasPublicCurieInAddressing(value, parentKey, depth = 0) {
+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) return false;
-	if (Array.isArray(value)) return value.some((item) => hasPublicCurieInAddressing(item, parentKey, depth + 1));
+	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], key, depth + 1)) return true;
+		if (hasPublicCurieInAddressing(record[key], preserveSecured, key, depth + 1)) return true;
 	}
 	return false;
 }
-function rewritePublicAudience(value, parentKey, depth = 0) {
+function rewritePublicAudience(value, preserveSecured, parentKey, depth = 0) {
 	if (typeof value === "string" && parentKey != null && PUBLIC_ADDRESSING_FIELDS.has(parentKey) && (value === "as:Public" || value === "Public")) return PUBLIC_COLLECTION.href;
 	if (depth >= MAX_TRAVERSAL_DEPTH) return value;
 	if (Array.isArray(value)) {
 		let changed = false;
 		const mapped = value.map((item) => {
-			const rewritten = rewritePublicAudience(item, parentKey, depth + 1);
+			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] : rewritePublicAudience(record[key], key, depth + 1);
+		const rewritten = key === "@context" ? record[key] : record.type === "Follow" && key === "object" && (record[key] === "as:Public" || record[key] === "Public") ? PUBLIC_COLLECTION.href : rewritePublicAudience(record[key], preserveSecured, key, depth + 1);
 		if (rewritten !== record[key]) changed = true;
 		normalized[key] = rewritten;
 	}
@@ -168,9 +172,10 @@ function hasKnownSafeContext(jsonLd) {
 * using the `eddsa-jcs-2022` cryptosuite), so the signed payload
 * matches what is sent on the wire.
 */
-async function normalizePublicAudience(jsonLd, contextLoader) {
-	if (!hasPublicCurieInAddressing(jsonLd)) return jsonLd;
-	const normalized = rewritePublicAudience(jsonLd);
+async function normalizePublicAudience(jsonLd, contextLoader, options = {}) {
+	const preserveSecured = options.preserveNestedSecuredDocuments ?? false;
+	if (!hasPublicCurieInAddressing(jsonLd, preserveSecured)) return jsonLd;
+	const normalized = rewritePublicAudience(jsonLd, preserveSecured);
 	if (hasKnownSafeContext(jsonLd)) return normalized;
 	const loader = contextLoader ?? preloadedOnlyDocumentLoader;
 	try {

package/dist/router-u5O5KCQr.mjs

@@ -0,0 +1,156 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { getLogger } from "@logtape/logtape";
+import { Router, RouterError, assertPath, isPath } from "@fedify/uri-template";
+//#region src/federation/router.ts
+const logger = getLogger([
+	"fedify",
+	"federation",
+	"router",
+	"deprecated"
+]);
+let deprecationWarned = false;
+function warnDeprecated() {
+	if (deprecationWarned) return;
+	deprecationWarned = true;
+	logger.warn("The `Router` and `RouterError` classes from `@fedify/fedify` are deprecated.  Please use `Router` from `@fedify/uri-template` instead.");
+}
+/**
+* URL router and constructor based on URI Template
+* ([RFC 6570](https://tools.ietf.org/html/rfc6570)).
+*
+* @deprecated Import `Router` from `@fedify/uri-template` instead.  This class
+*             remains only for compatibility with older Fedify code.  The
+*             `@fedify/uri-template` router is the replacement implementation
+*             and should be used directly in new code.
+*/
+var Router$1 = class Router$1 {
+	#router;
+	/**
+	* Create a new {@link Router}.
+	* @param options Options for the router.
+	* @deprecated Use `new Router(options)` from `@fedify/uri-template`
+	*             instead.
+	*/
+	constructor(options) {
+		this.#router = convertRouterError(() => new Router(options));
+	}
+	/**
+	* Whether to ignore trailing slashes when matching paths.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  This
+	*             accessor forwards to the underlying `@fedify/uri-template`
+	*             router so that post-construction mutation keeps working as
+	*             in older Fedify code.
+	*/
+	get trailingSlashInsensitive() {
+		return this.#router.trailingSlashInsensitive;
+	}
+	set trailingSlashInsensitive(value) {
+		this.#router.trailingSlashInsensitive = value;
+	}
+	/**
+	* Clones this router.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	clone() {
+		return convertRouterError(() => {
+			const clone = new Router$1();
+			clone.#router = this.#router.clone();
+			return clone;
+		});
+	}
+	/**
+	* Checks if a path name exists in the router.
+	* @param name The name of the path.
+	* @returns `true` if the path name exists, otherwise `false`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	has(name) {
+		return convertRouterError(() => this.#router.has(name));
+	}
+	/**
+	* Adds a new path rule to the router.
+	* @param template The path pattern.
+	* @param name The name of the path.
+	* @returns The names of the variables in the path pattern.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  In this
+	*             compatibility class, `add()` both registers the route and
+	*             returns the variables in the path pattern.  In
+	*             `@fedify/uri-template`, these two responsibilities are split:
+	*             `router.add(template, name)` registers the route and returns
+	*             `void`, while the pure static method
+	*             `Router.variables(template)` returns the variable names.  To
+	*             migrate, call `Router.variables(template)` when variables are
+	*             needed, then call `router.add(template, name)` to register the
+	*             route.
+	*/
+	add(template, name) {
+		return convertRouterError(() => {
+			assertPath(template);
+			this.#router.add(template, name);
+			return Router.variables(template);
+		});
+	}
+	/**
+	* Resolves a path name and values from a URL, if any match.
+	* @param url The URL to resolve.
+	* @returns The name of the path and its values, if any match.  Otherwise,
+	*          `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.  Unlike the
+	*             stricter `@fedify/uri-template` router, this compatibility
+	*             method keeps the old Fedify 2.x contract of returning `null`
+	*             (rather than throwing) for inputs that are not router paths.
+	*/
+	route(url) {
+		return convertRouterError(() => {
+			if (!isPath(url)) return null;
+			return this.#router.route(url);
+		});
+	}
+	/**
+	* Constructs a URL/path from a path name and values.
+	* @param name The name of the path.
+	* @param values The values to expand the path with.
+	* @returns The URL/path, if the name exists.  Otherwise, `null`.
+	* @deprecated Use `Router` from `@fedify/uri-template` instead.
+	*/
+	build(name, values) {
+		return convertRouterError(() => this.#router.build(name, values));
+	}
+};
+/**
+* An error thrown by the {@link Router}.
+* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+*/
+var RouterError$1 = class extends RouterError {
+	/**
+	* Treats every `RouterError` from `@fedify/uri-template` as an instance of
+	* this deprecated class.
+	*
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	static [Symbol.hasInstance](instance) {
+		return instance instanceof RouterError;
+	}
+	/**
+	* Create a new {@link RouterError}.
+	* @param message The error message.
+	* @deprecated Import `RouterError` from `@fedify/uri-template` instead.
+	*/
+	constructor(message) {
+		super(message);
+		warnDeprecated();
+	}
+};
+function convertRouterError(func) {
+	try {
+		warnDeprecated();
+		return func();
+	} catch (error) {
+		if (error instanceof RouterError) throw new RouterError$1(error.message);
+		throw error;
+	}
+}
+//#endregion
+export { RouterError$1 as n, Router$1 as t };

package/dist/runtime/mod.cjs

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
-require("../chunk-Czpeue4M.cjs");
+require("../rolldown-runtime-Dmm3t92W.cjs");
 var _fedify_vocab_runtime = require("@fedify/vocab-runtime");
 Object.keys(_fedify_vocab_runtime).forEach(function(k) {
 	if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/dist/runtime/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import "../chunk-D5IdezsZ.js";
+import "../rolldown-runtime-BC-Eo5Mj.js";
 export * from "@fedify/vocab-runtime";

package/dist/secured-document-CxzZZ9nL.mjs

@@ -0,0 +1,35 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+//#region src/compat/secured-document.ts
+function isJsonMap(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(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(proof)) return false;
+	return hasDataIntegrityProofType(proof.type) && isNonEmptyString(proof.cryptosuite) && isNonEmptyString(proof.created) && isNonEmptyString(proof.verificationMethod) && isNonEmptyString(proof.proofPurpose) && isNonEmptyString(proof.proofValue);
+}
+//#endregion
+export { isSelfContainedSecuredDocument as t };