@fedify/fedify 2.3.0-dev.994 → 2.3.0-pr.809.36

package/dist/sig/mod.cjs

@@ -1,8 +1,8 @@
 const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http = require("../http-BrGqJDXL.cjs");
-const require_proof = require("../proof-BW89QMVB.cjs");
+const require_http = require("../http-gOiudB3g.cjs");
+const require_proof = require("../proof-tz35unOj.cjs");
 exports.attachSignature = require_proof.attachSignature;
 exports.createProof = require_proof.createProof;
 exports.createSignature = require_proof.createSignature;

package/dist/sig/mod.d.cts

@@ -1,4 +1,5 @@
-import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-CrGuipxe.cjs";
-import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-CptqhsOy.cjs";
-import { _ as hasSignatureLike, a as createProof, b as verifySignature, c as verifyObject, d as SignJsonLdOptions, f as VerifyJsonLdOptions, g as detachSignature, h as createSignature, i as VerifyProofOptions, l as verifyProof, m as attachSignature, n as SignObjectOptions, o as hasProofLike, p as VerifySignatureOptions, r as VerifyObjectOptions, s as signObject, t as CreateProofOptions, u as CreateSignatureOptions, v as signJsonLd, y as verifyJsonLd } from "../mod-Cr3f-ACa.cjs";
+/// <reference lib="esnext.temporal" />
+import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-VyDTd4G3.cjs";
+import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-DEvZuyOE.cjs";
+import { _ as hasSignatureLike, a as createProof, b as verifySignature, c as verifyObject, d as SignJsonLdOptions, f as VerifyJsonLdOptions, g as detachSignature, h as createSignature, i as VerifyProofOptions, l as verifyProof, m as attachSignature, n as SignObjectOptions, o as hasProofLike, p as VerifySignatureOptions, r as VerifyObjectOptions, s as signObject, t as CreateProofOptions, u as CreateSignatureOptions, v as signJsonLd, y as verifyJsonLd } from "../mod-B0hW12_O.cjs";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/mod.d.ts

@@ -1,6 +1,5 @@
-import { Temporal } from "@js-temporal/polyfill";
-import { URLPattern } from "urlpattern-polyfill";
-import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-aQzN9Ayi.js";
-import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-74ARJ5TL.js";
-import { _ as hasSignatureLike, a as createProof, b as verifySignature, c as verifyObject, d as SignJsonLdOptions, f as VerifyJsonLdOptions, g as detachSignature, h as createSignature, i as VerifyProofOptions, l as verifyProof, m as attachSignature, n as SignObjectOptions, o as hasProofLike, p as VerifySignatureOptions, r as VerifyObjectOptions, s as signObject, t as CreateProofOptions, u as CreateSignatureOptions, v as signJsonLd, y as verifyJsonLd } from "../mod-CR8soWa9.js";
+/// <reference lib="esnext.temporal" />
+import { C as exportJwk, D as importJwk, E as generateCryptoKeyPair, S as KeyCache, T as fetchKeyDetailed, _ as validateAcceptSignature, a as VerifyRequestDetailedResult, b as FetchKeyOptions, c as signRequest, d as AcceptSignatureMember, f as AcceptSignatureParameters, g as parseAcceptSignature, h as fulfillAcceptSignature, i as SignRequestOptions, l as verifyRequest, m as formatAcceptSignature, n as HttpMessageSignaturesSpecDeterminer, o as VerifyRequestFailureReason, p as FulfillAcceptSignatureResult, r as Rfc9421SignRequestOptions, s as VerifyRequestOptions, t as HttpMessageSignaturesSpec, u as verifyRequestDetailed, v as FetchKeyDetailedResult, w as fetchKey, x as FetchKeyResult, y as FetchKeyErrorResult } from "../http-lf8Hsd91.js";
+import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-CnngXDNJ.js";
+import { _ as hasSignatureLike, a as createProof, b as verifySignature, c as verifyObject, d as SignJsonLdOptions, f as VerifyJsonLdOptions, g as detachSignature, h as createSignature, i as VerifyProofOptions, l as verifyProof, m as attachSignature, n as SignObjectOptions, o as hasProofLike, p as VerifySignatureOptions, r as VerifyObjectOptions, s as signObject, t as CreateProofOptions, u as CreateSignatureOptions, v as signJsonLd, y as verifyJsonLd } from "../mod-COIAjwRS.js";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/mod.js

@@ -1,5 +1,5 @@
-import "@js-temporal/polyfill";
-import "urlpattern-polyfill";
-import { a as verifyRequestDetailed, c as fetchKeyDetailed, f as formatAcceptSignature, h as validateAcceptSignature, i as verifyRequest, l as generateCryptoKeyPair, m as parseAcceptSignature, o as exportJwk, p as fulfillAcceptSignature, r as signRequest, s as fetchKey, u as importJwk } from "../http-B4rrzxtg.js";
-import { a as verifyProof, c as getKeyOwner, d as detachSignature, f as hasSignatureLike, h as verifySignature, i as verifyObject, l as attachSignature, m as verifyJsonLd, n as hasProofLike, p as signJsonLd, r as signObject, s as doesActorOwnKey, t as createProof, u as createSignature } from "../proof-Bbbwf8_x.js";
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+import { A as formatAcceptSignature, M as parseAcceptSignature, N as validateAcceptSignature, a as verifyRequestDetailed, c as fetchKeyDetailed, i as verifyRequest, j as fulfillAcceptSignature, l as generateCryptoKeyPair, o as exportJwk, r as signRequest, s as fetchKey, u as importJwk } from "../http-Dh18nwJg.js";
+import { C as verifySignature, S as verifyJsonLd, _ as hasSignatureLike, a as verifyProof, b as signJsonLd, c as getKeyOwner, d as attachSignature, i as verifyObject, m as detachSignature, n as hasProofLike, p as createSignature, r as signObject, s as doesActorOwnKey, t as createProof } from "../proof-CyXndf6-.js";
 export { attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/owner.test.mjs

@@ -1,14 +1,14 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { r as assertFalse } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
 import { o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-DGu1NFwu.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-C-tqfvxn.mjs";
-import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-Cl-1cAR8.mjs";
 import { Create, CryptographicKey, lookupObject } from "@fedify/vocab";
+import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/sig/owner.test.ts
 test("doesActorOwnKey()", async () => {
 	const options = {

package/dist/sig/proof.test.mjs

@@ -1,16 +1,16 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-CRDpx_HF.mjs";
-import { n as assertFalse, t as assertRejects } from "../assert_rejects-B-qJtC9Z.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { n as assertGreaterOrEqual, r as assertFalse, t as assertRejects } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-DBC5X09g.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DGu1NFwu.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-CNmZLixq.mjs";
-import { a as verifyProof, i as verifyObject, n as hasProofLike, r as signObject, t as createProof } from "../proof-BlmRPzrK.mjs";
-import { mockDocumentLoader, test } from "@fedify/fixture";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-L_DbOaFe.mjs";
+import { a as verifyProof, i as verifyObject, n as hasProofLike, r as signObject, t as createProof } from "../proof-Dnz8jtiQ.mjs";
 import { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place } from "@fedify/vocab";
+import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { decodeMultibase, importMultibaseKey } from "@fedify/vocab-runtime";
 import { decodeHex } from "byte-encodings/hex";
 //#region src/sig/proof.test.ts
@@ -326,6 +326,167 @@ test("verifyProof()", async () => {
 	}), null);
 	assertFalse(contextLoaderCalls.includes("https://attacker.example/ctx"));
 });
+test("verifyProof() records verification duration metric", async (t) => {
+	const jsonLd = {
+		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"],
+		id: "https://server.example/activities/1",
+		type: "Create",
+		actor: "https://server.example/users/alice",
+		object: {
+			id: "https://server.example/objects/1",
+			type: "Note",
+			attributedTo: "https://server.example/users/alice",
+			content: "Hello world",
+			location: {
+				type: "Place",
+				longitude: -71.184902,
+				latitude: 25.273962
+			}
+		}
+	};
+	const proof = new DataIntegrityProof({
+		cryptosuite: "eddsa-jcs-2022",
+		verificationMethod: new URL("https://server.example/users/alice#ed25519-key"),
+		proofPurpose: "assertionMethod",
+		proofValue: decodeMultibase("zLaewdp4H9kqtwyrLatK4cjY5oRHwVcw4gibPSUDYDMhi4M49v8pcYk3ZB6D69dNpAPbUmY8ocuJ3m9KhKJEEg7z"),
+		created: Temporal.Instant.from("2023-02-24T23:36:38Z")
+	});
+	await t.step("verified path records result=verified with bounded cryptosuite", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assert(await verifyProof(jsonLd, proof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider
+		}) != null);
+		const measurements = recorder.getMeasurements("activitypub.signature.verification.duration");
+		assertEquals(measurements.length, 1);
+		const m = measurements[0];
+		assertEquals(m.type, "histogram");
+		assertGreaterOrEqual(m.value, 0);
+		assertEquals(m.attributes["activitypub.signature.kind"], "object_integrity");
+		assertEquals(m.attributes["activitypub.signature.result"], "verified");
+		assertEquals(m.attributes["object_integrity_proofs.cryptosuite"], "eddsa-jcs-2022");
+	});
+	await t.step("rejected path records result=rejected", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assertEquals(await verifyProof({
+			...jsonLd,
+			object: {
+				...jsonLd.object,
+				content: "bye"
+			}
+		}, proof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider
+		}), null);
+		const measurements = recorder.getMeasurements("activitypub.signature.verification.duration");
+		assertEquals(measurements.length, 1);
+		assertEquals(measurements[0].attributes["activitypub.signature.result"], "rejected");
+		assertEquals(measurements[0].attributes["object_integrity_proofs.cryptosuite"], "eddsa-jcs-2022");
+	});
+	await t.step("cached-key retry emits one measurement, not two", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const cache = { ["https://server.example/users/alice#ed25519-key"]: ed25519Multikey };
+		assert(await verifyProof(jsonLd, proof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider,
+			keyCache: {
+				get(id) {
+					return Promise.resolve(cache[id.href]);
+				},
+				set(id, k) {
+					cache[id.href] = k;
+					return Promise.resolve();
+				}
+			}
+		}) != null);
+		assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 1);
+		const keyFetches = recorder.getMeasurements("activitypub.signature.key_fetch.duration");
+		assertEquals(keyFetches.length, 2);
+		assertEquals(keyFetches[0].attributes["activitypub.signature.key_fetch.result"], "hit");
+		assertEquals(keyFetches[1].attributes["activitypub.signature.key_fetch.result"], "fetched");
+	});
+	await t.step("key fetch records result=fetched on a cold cache", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assert(await verifyProof(jsonLd, proof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider
+		}) != null);
+		const measurements = recorder.getMeasurements("activitypub.signature.key_fetch.duration");
+		assertEquals(measurements.length, 1);
+		assertGreaterOrEqual(measurements[0].value, 0);
+		assertEquals(measurements[0].attributes["activitypub.signature.kind"], "object_integrity");
+		assertEquals(measurements[0].attributes["activitypub.signature.key_fetch.result"], "fetched");
+	});
+	await t.step("key fetch records result=hit when served from the key cache", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const cache = { "https://server.example/users/alice#ed25519-key": new Multikey({
+			id: new URL("https://server.example/users/alice#ed25519-key"),
+			controller: new URL("https://server.example/users/alice"),
+			publicKey: await importMultibaseKey("z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2")
+		}) };
+		assert(await verifyProof(jsonLd, proof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider,
+			keyCache: {
+				get(id) {
+					return Promise.resolve(cache[id.href]);
+				},
+				set(id, k) {
+					cache[id.href] = k;
+					return Promise.resolve();
+				}
+			}
+		}) != null);
+		const measurements = recorder.getMeasurements("activitypub.signature.key_fetch.duration");
+		assertEquals(measurements.length, 1);
+		assertEquals(measurements[0].attributes["activitypub.signature.key_fetch.result"], "hit");
+	});
+	await t.step("verifyObject() wrapper emits one measurement per inner verifyProof()", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		assert(await verifyObject(Create, {
+			...jsonLd,
+			proof: await proof.toJsonLd({
+				format: "compact",
+				contextLoader: mockDocumentLoader
+			})
+		}, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider
+		}) != null);
+		assertEquals(recorder.getMeasurements("activitypub.signature.verification.duration").length, 1);
+	});
+	await t.step("unknown cryptosuite omits the cryptosuite metric attribute", async () => {
+		const [meterProvider, recorder] = createTestMeterProvider();
+		const exoticProof = await DataIntegrityProof.fromJsonLd({
+			"@context": "https://w3id.org/security/data-integrity/v1",
+			type: "DataIntegrityProof",
+			cryptosuite: "made-up-suite-9999",
+			verificationMethod: "https://server.example/users/alice#ed25519-key",
+			proofPurpose: "assertionMethod",
+			proofValue: "zLaewdp4H9kqtwyrLatK4cjY5oRHwVcw4gibPSUDYDMhi4M49v8pcYk3ZB6D69dNpAPbUmY8ocuJ3m9KhKJEEg7z",
+			created: "2023-02-24T23:36:38Z"
+		}, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertEquals(exoticProof.cryptosuite, "made-up-suite-9999");
+		assertEquals(await verifyProof(jsonLd, exoticProof, {
+			documentLoader: mockDocumentLoader,
+			contextLoader: mockDocumentLoader,
+			meterProvider
+		}), null);
+		const measurements = recorder.getMeasurements("activitypub.signature.verification.duration");
+		assertEquals(measurements.length, 1);
+		assertEquals(measurements[0].attributes["activitypub.signature.result"], "rejected");
+		assertFalse("object_integrity_proofs.cryptosuite" in measurements[0].attributes);
+	});
+});
 test("verifyObject()", async () => {
 	const options = {
 		documentLoader: mockDocumentLoader,

package/dist/{std__assert-CRDpx_HF.mjs → std__assert-BBjXFNOb.mjs}

@@ -1,10 +1,10 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { l as AssertionError, s as format } from "./assert_equals-Ew3jOFa3.mjs";
-import "./assert_rejects-B-qJtC9Z.mjs";
-import "./assert_throws-4NwKEy2q.mjs";
-import "./assert_strict_equals-Dmjbg-bA.mjs";
+import { l as AssertionError, s as format } from "./assert_equals-C-ZRDbaf.mjs";
+import "./assert_rejects-DN60FHPX.mjs";
+import "./assert_throws-BOkhLGYc.mjs";
+import "./assert_strict_equals-XEgZAlrj.mjs";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_exists.js
 /**
 * Make an assertion that actual is not null or undefined.
@@ -28,31 +28,6 @@ import "./assert_strict_equals-Dmjbg-bA.mjs";
 	}
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater_or_equal.js
-/**
-* Make an assertion that `actual` is greater than or equal to `expected`.
-* If not then throw.
-*
-* @example Usage
-* ```ts no-eval
-* import { assertGreaterOrEqual } from "@std/assert/assert-greater-or-equal";
-*
-* assertGreaterOrEqual(2, 1); // Doesn't throw
-* assertGreaterOrEqual(1, 1); // Doesn't throw
-* assertGreaterOrEqual(0, 1); // Throws
-* ```
-*
-* @typeParam T The type of the values to compare.
-* @param actual The actual value to compare.
-* @param expected The expected value to compare.
-* @param msg The optional message to display if the assertion fails.
-*/ function assertGreaterOrEqual(actual, expected, msg) {
-	if (actual >= expected) return;
-	const actualString = format(actual);
-	const expectedString = format(expected);
-	throw new AssertionError(msg ?? `Expect ${actualString} >= ${expectedString}`);
-}
-//#endregion
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_greater.js
 /**
 * Make an assertion that `actual` is greater than `expected`.
@@ -101,4 +76,4 @@ import "./assert_strict_equals-Dmjbg-bA.mjs";
 	}
 }
 //#endregion
-export { assertExists as i, assertGreater as n, assertGreaterOrEqual as r, assertStringIncludes as t };
+export { assertGreater as n, assertExists as r, assertStringIncludes as t };

package/dist/temporal-BEwob1Vg.mjs

@@ -0,0 +1,95 @@
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { c as getNormalizationContextLoader } from "./ld-0Lsznacf.mjs";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+//#region src/federation/temporal.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function normalizeDateTimeLiteral(value) {
+	return value.substring(19).match(/[Z+-]/) ? value : value + "Z";
+}
+function isMalformedDateTimeLiteral(value) {
+	if (typeof value !== "string") return false;
+	try {
+		Temporal.Instant.from(normalizeDateTimeLiteral(value));
+		return false;
+	} catch {
+		return true;
+	}
+}
+function isMalformedDurationLiteral(value) {
+	if (typeof value !== "string") return false;
+	try {
+		Temporal.Duration.from(value);
+		return false;
+	} catch {
+		return true;
+	}
+}
+const TEMPORAL_DATE_TIME_IRIS = new Set([
+	"https://www.w3.org/ns/activitystreams#deleted",
+	"https://www.w3.org/ns/activitystreams#endTime",
+	"https://www.w3.org/ns/activitystreams#published",
+	"https://www.w3.org/ns/activitystreams#startTime",
+	"https://www.w3.org/ns/activitystreams#updated",
+	"http://purl.org/dc/terms/created",
+	"https://w3id.org/security#created"
+]);
+const TEMPORAL_DURATION_IRIS = new Set(["https://www.w3.org/ns/activitystreams#duration"]);
+const QUESTION_CLOSED_IRI = "https://www.w3.org/ns/activitystreams#closed";
+const XSD_DATE_TIME_IRI = "http://www.w3.org/2001/XMLSchema#dateTime";
+function hasMalformedExpandedDateTimeLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedDateTimeLiteral);
+	return isPlainObject(value) && "@value" in value && isMalformedDateTimeLiteral(value["@value"]);
+}
+function hasMalformedExpandedQuestionClosedLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedQuestionClosedLiteral);
+	if (!isPlainObject(value) || !("@value" in value)) return false;
+	const literal = value["@value"];
+	if (typeof literal === "boolean") return false;
+	if (typeof literal !== "string") return false;
+	if (value["@type"] !== XSD_DATE_TIME_IRI) return false;
+	if (new Date(literal).toString() === "Invalid Date") return false;
+	return isMalformedDateTimeLiteral(literal);
+}
+function hasMalformedExpandedDurationLiteral(value) {
+	if (Array.isArray(value)) return value.some(hasMalformedExpandedDurationLiteral);
+	return isPlainObject(value) && "@value" in value && isMalformedDurationLiteral(value["@value"]);
+}
+function hasMalformedKnownTemporalLiteralInternal(value, visited) {
+	if (Array.isArray(value)) return value.some((item) => hasMalformedKnownTemporalLiteralInternal(item, visited));
+	if (!isPlainObject(value)) return false;
+	if (visited.has(value)) return false;
+	visited.add(value);
+	if ("@value" in value) return false;
+	for (const [key, child] of Object.entries(value)) {
+		if (TEMPORAL_DATE_TIME_IRIS.has(key)) {
+			if (hasMalformedExpandedDateTimeLiteral(child)) return true;
+			continue;
+		}
+		if (key === QUESTION_CLOSED_IRI) {
+			if (hasMalformedExpandedQuestionClosedLiteral(child)) return true;
+			continue;
+		}
+		if (TEMPORAL_DURATION_IRIS.has(key)) {
+			if (hasMalformedExpandedDurationLiteral(child)) return true;
+			continue;
+		}
+		if (hasMalformedKnownTemporalLiteralInternal(child, visited)) return true;
+	}
+	return false;
+}
+async function hasMalformedKnownTemporalLiteral(value, contextLoader) {
+	try {
+		return hasMalformedKnownTemporalLiteralInternal(await jsonld.expand(value, {
+			documentLoader: getNormalizationContextLoader(contextLoader),
+			keepFreeFloatingNodes: true
+		}), /* @__PURE__ */ new Set());
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { hasMalformedKnownTemporalLiteral as t };

package/dist/testing/mod.d.mts

@@ -1,10 +1,12 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { testDefinitions } from "@fedify/fixture";
+import { ExportResultCode } from "@opentelemetry/core";
+import { Router } from "@fedify/uri-template";
 import { Activity, Actor, Collection, CryptographicKey, Hashtag, Link, LookupObjectOptions, Multikey, Object as Object$1, Recipient, Tombstone, TraverseCollectionOptions } from "@fedify/vocab";
 import { Link as Link$1, LookupWebFingerOptions, ResourceDescriptor } from "@fedify/webfinger";
-import { TracerProvider } from "@opentelemetry/api";
+import { MeterProvider, TracerProvider } from "@opentelemetry/api";
 import { DocumentLoader, GetUserAgentOptions } from "@fedify/vocab-runtime";
+import { MeterProvider as MeterProvider$1, MetricReader } from "@opentelemetry/sdk-metrics";
 
 //#region src/nodeinfo/types.d.ts
 /**
@@ -263,14 +265,20 @@ declare class SendActivityError extends Error {
    * If truncated, the string will end with `"… (truncated)"`.
    */
   readonly responseBody: string;
+  /**
+   * The response headers from the inbox.
+   * @since 2.3.0
+   */
+  readonly responseHeaders: Headers;
   /**
    * Creates a new {@link SendActivityError}.
    * @param inbox The inbox URL.
    * @param statusCode The HTTP status code.
    * @param message The error message.
    * @param responseBody The response body.
+   * @param responseHeaders The response headers.
    */
-  constructor(inbox: URL, statusCode: number, message: string, responseBody: string);
+  constructor(inbox: URL, statusCode: number, message: string, responseBody: string, responseHeaders?: HeadersInit);
 }
 //#endregion
 //#region src/federation/callback.d.ts
@@ -484,10 +492,27 @@ type SharedInboxKeyDispatcher<TContextData> = (context: Context<TContextData>) =
  * @since 2.0.0
  */
 type OutboxPermanentFailureHandler<TContextData> = (context: Context<TContextData>, values: {
-  /** The inbox URL that failed. */readonly inbox: URL; /** The activity that failed to deliver. */
+  /**
+   * Why Fedify is giving up on delivery.
+   *
+   * `"http"` means the inbox returned a configured permanent-failure HTTP
+   * status.  `"circuit-breaker-ttl"` means the outbound circuit breaker held
+   * the activity until its retention period expired.
+   *
+   * @since 2.3.0
+   */
+  readonly reason: "http" | "circuit-breaker-ttl"; /** The inbox URL that failed. */
+  readonly inbox: URL; /** The activity that failed to deliver. */
   readonly activity: Activity; /** The error that occurred. */
   readonly error: SendActivityError; /** The HTTP status code returned by the inbox. */
   readonly statusCode: number;
+  /**
+   * The time when the circuit breaker first held the activity, if
+   * {@link reason} is `"circuit-breaker-ttl"`.
+   *
+   * @since 2.3.0
+   */
+  readonly circuitHeldSince?: Temporal.Instant;
   /**
    * The actor IDs that were supposed to receive the activity at this inbox.
    */
@@ -610,6 +635,17 @@ interface OutboxMessage {
   readonly attempt: number;
   readonly headers: Readonly<Record<string, string>>;
   readonly orderingKey?: string;
+  /**
+   * Whether this message is currently held by the outbound circuit breaker.
+   * @internal
+   */
+  readonly circuitHeld?: true;
+  /**
+   * When Fedify first held this message because the remote host circuit was
+   * open.
+   * @internal
+   */
+  readonly circuitHeldSince?: string;
   readonly traceContext: Readonly<Record<string, string>>;
 }
 interface InboxMessage {
@@ -617,6 +653,42 @@ interface InboxMessage {
   readonly id: ReturnType<typeof crypto.randomUUID>;
   readonly baseUrl: string;
   readonly activity: unknown;
+  /**
+   * The normalized JSON-LD representation of a signed inbox activity that
+   * Fedify already compacted successfully while accepting the request.  Queue
+   * workers can reuse this producer-side parse cache under stricter loader or
+   * network constraints without changing the raw payload preserved for
+   * forwarding.
+   *
+   * This may exist even when {@link ldSignatureVerified} is `false`, because
+   * fallback-authenticated traffic and already-queued backlog items can still
+   * depend on the cached normalized form to avoid re-fetching remote custom
+   * contexts during worker processing.
+   *
+   * This is optional for backward compatibility with messages that were
+   * queued by older Fedify versions or that were already in a queue before
+   * upgrading.
+   *
+   * Fedify keeps this on the queued message itself instead of an external
+   * sidecar because generic queue backends do not provide reliable lifecycle
+   * guarantees for auxiliary storage across retries and redeliveries.
+   *
+   * @internal
+   */
+  readonly normalizedActivity?: unknown;
+  /**
+   * Whether the producer actually verified the Linked Data Signature before
+   * queueing this message.  This lets workers distinguish verified LDS replay
+   * from other authenticated inbox traffic that merely happened to include a
+   * signature block.  This provenance marker is separate from the optional
+   * normalizedActivity parse cache.
+   *
+   * `undefined` preserves backward compatibility with older queued messages
+   * that predate this marker.
+   *
+   * @internal
+   */
+  readonly ldSignatureVerified?: boolean;
   readonly started: string;
   readonly attempt: number;
   readonly identifier: string | null;
@@ -1137,6 +1209,18 @@ interface ActorCallbackSetters<TContextData> {
    * @since 1.4.0
    */
   mapAlias(mapper: ActorAliasMapper<TContextData>): ActorCallbackSetters<TContextData>;
+  /**
+   * Maps a fixed path to a sentinel identifier.  It is useful for exposing
+   * a single, instance-level actor at a fixed path, such as `/actor` for
+   * a relay or `/bot` for a bot.
+   * @param path The fixed path to map to the identifier.
+   * @param identifier The sentinel identifier to map the path to.
+   * @returns The setters object so that settings can be chained.
+   * @throws {RouterError} If the provided path or identifier is invalid or fails
+   *                       runtime validation.
+   * @since 2.3.0
+   */
+  mapActorAlias(path: `/${string}`, identifier: string): ActorCallbackSetters<TContextData>;
   /**
    * Specifies the conditions under which requests are authorized.
    * @param predicate A callback that returns whether a request is authorized.
@@ -1495,6 +1579,11 @@ interface Context<TContextData> {
    * @since 1.3.0
    */
   readonly tracerProvider: TracerProvider;
+  /**
+   * The OpenTelemetry meter provider.
+   * @since 2.3.0
+   */
+  readonly meterProvider?: MeterProvider;
   /**
    * The document loader for loading remote JSON-LD documents.
    */
@@ -1993,9 +2082,12 @@ interface InboxContext<TContextData> extends Context<TContextData> {
    * Forwards a received activity to the recipients' inboxes.  The forwarded
    * activity will be signed in HTTP Signatures by the forwarder, but its
    * payload will not be modified, i.e., Linked Data Signatures and Object
-   * Integrity Proofs will not be added.  Therefore, if the activity is not
-   * signed (i.e., it has neither Linked Data Signatures nor Object Integrity
-   * Proofs), the recipient probably will not trust the activity.
+   * Integrity Proofs will not be added.  Even when Fedify internally
+   * normalizes a Linked Data Signature activity for parsing, this method still
+   * forwards the original received payload so the sender's signatures/proofs
+   * are preserved as-is.  Therefore, if the activity is not signed (i.e., it
+   * has neither Linked Data Signatures nor Object Integrity Proofs), the
+   * recipient probably will not trust the activity.
    * @param forwarder The forwarder's identifier or the forwarder's username
    *                  or the forwarder's key pair(s).
    * @param recipients The recipients of the activity.
@@ -2011,9 +2103,12 @@ interface InboxContext<TContextData> extends Context<TContextData> {
    * Forwards a received activity to the recipients' inboxes.  The forwarded
    * activity will be signed in HTTP Signatures by the forwarder, but its
    * payload will not be modified, i.e., Linked Data Signatures and Object
-   * Integrity Proofs will not be added.  Therefore, if the activity is not
-   * signed (i.e., it has neither Linked Data Signatures nor Object Integrity
-   * Proofs), the recipient probably will not trust the activity.
+   * Integrity Proofs will not be added.  Even when Fedify internally
+   * normalizes a Linked Data Signature activity for parsing, this method still
+   * forwards the original received payload so the sender's signatures/proofs
+   * are preserved as-is.  Therefore, if the activity is not signed (i.e., it
+   * has neither Linked Data Signatures nor Object Integrity Proofs), the
+   * recipient probably will not trust the activity.
    * @param forwarder The forwarder's identifier or the forwarder's username.
    * @param recipients In this case, it must be `"followers"`.
    * @param options Options for forwarding the activity.
@@ -2375,4 +2470,9 @@ declare function createOutboxContext<TContextData>(args: Partial<OutboxContext<T
   federation: Federation<TContextData>;
 }): OutboxContext<TContextData>;
 //#endregion
+//#region ../fixture/dist/mod.d.ts
+//#endregion
+//#region src/test.d.ts
+declare const testDefinitions: Deno.TestDefinition[];
+//#endregion
 export { createInboxContext, createOutboxContext, createRequestContext, testDefinitions };

package/dist/testing/mod.mjs

@@ -1,6 +1,5 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-Dk_tacqz.mjs";
-import { testDefinitions } from "@fedify/fixture";
+import { i as testDefinitions, n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-DVoTs_wM.mjs";
 export { createInboxContext, createOutboxContext, createRequestContext, testDefinitions };

package/dist/{transformers-ve6e2xcg.js → transformers-BGMIq1cs.js}

@@ -1,5 +1,5 @@
-import "@js-temporal/polyfill";
-import "urlpattern-polyfill";
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
 import { getLogger } from "@logtape/logtape";
 //#region src/compat/transformers.ts
 const logger = getLogger([

package/dist/{types-hvL8ElAs.js → types-CAY3OdLq.js}

@@ -1,5 +1,5 @@
-import "@js-temporal/polyfill";
-import "urlpattern-polyfill";
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
 import { getLogger } from "@logtape/logtape";
 import { getUserAgent } from "@fedify/vocab-runtime";
 //#region src/nodeinfo/client.ts