@fedify/fedify 2.4.0-dev.2010 → 2.4.0-dev.2030

package/dist/sig/compound-proof-producer.test.mjs

@@ -0,0 +1,107 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { i as inspectCompoundPortableObjectApplicability, r as findUnsupportedCompoundProofShape, t as containsCompoundPortableObject } from "../compound-proof-BIvUoJxm.mjs";
+import { test } from "@fedify/fixture";
+//#region src/sig/compound-proof-producer.test.ts
+const portableId = "ap+ef61://did:key:z6MkAlice/objects/1";
+const proof = {
+	type: "DataIntegrityProof",
+	proofValue: "z"
+};
+function nest(depth, leaf) {
+	let value = leaf;
+	for (let i = 0; i < depth; i++) value = {
+		type: "Note",
+		content: value
+	};
+	return value;
+}
+test("containsCompoundPortableObject() finds portable maps", () => {
+	const cases = [
+		[{ id: portableId }, true],
+		[{ "@id": "AP://did:key:z6MkAlice/actor" }, true],
+		[{
+			id: "https://example.com/1",
+			object: [{}, { id: portableId }]
+		}, true],
+		[{
+			id: "https://example.com/1",
+			actor: portableId
+		}, false],
+		[{
+			id: "https://example.com/1",
+			proof: { id: portableId }
+		}, false],
+		[{
+			"@context": [{ id: portableId }],
+			id: "https://example.com/1"
+		}, false],
+		[{
+			id: "https://example.com/1",
+			object: { id: "ap-like" }
+		}, false],
+		[[{ id: portableId }], true],
+		[null, false]
+	];
+	for (const [json, expected] of cases) assertEquals(containsCompoundPortableObject(json), expected, `${json}`);
+});
+test("containsCompoundPortableObject() ignores the inbox limits", () => {
+	const deep = nest(100, { id: portableId });
+	const limits = {
+		maxDepth: 64,
+		maxMaps: 1e4,
+		maxProofs: 32,
+		maxBytes: 10 * 1024 * 1024
+	};
+	assertEquals(inspectCompoundPortableObjectApplicability(deep, limits), "indeterminate");
+	assertEquals(containsCompoundPortableObject(deep), true);
+	const large = {
+		id: "https://example.com/1",
+		content: "x".repeat(11 * 1024 * 1024),
+		proof: [proof, proof]
+	};
+	assertEquals(inspectCompoundPortableObjectApplicability(large, limits), "indeterminate");
+	assertEquals(containsCompoundPortableObject(large), false);
+});
+test("containsCompoundPortableObject() terminates on repeated maps", () => {
+	const shared = { type: "Note" };
+	const cyclic = {
+		a: shared,
+		b: shared
+	};
+	shared.parent = cyclic;
+	assertEquals(containsCompoundPortableObject(cyclic), false);
+	shared.id = portableId;
+	assertEquals(containsCompoundPortableObject(cyclic), true);
+});
+test("findUnsupportedCompoundProofShape() reports non-map proofs", () => {
+	const cases = [
+		[{ proof }, null],
+		[{ proof: [proof, proof] }, "/proof"],
+		[{ proof: [proof] }, "/proof"],
+		[{ proof: [] }, "/proof"],
+		[{ proof: null }, "/proof"],
+		[{ proof: "z" }, "/proof"],
+		[{ proof: 1 }, "/proof"],
+		[{ proof: true }, "/proof"],
+		[{
+			proof,
+			object: { proof: [proof, proof] }
+		}, "/object/proof"],
+		[{ items: [{ proof }, { proof: [proof] }] }, "/items/1/proof"],
+		[{ "a/b~c": { proof: [proof] } }, "/a~1b~0c/proof"],
+		[{ proof: {
+			...proof,
+			nested: { proof: [proof] }
+		} }, null],
+		[{ "@context": [{ proof: [proof] }] }, null],
+		[{ object: { id: portableId } }, null]
+	];
+	for (const [json, expected] of cases) assertEquals(findUnsupportedCompoundProofShape(json), expected, JSON.stringify(json));
+	assertEquals(findUnsupportedCompoundProofShape(nest(100, { proof: [proof, proof] })), "/content".repeat(100) + "/proof");
+});
+//#endregion
+export {};

package/dist/sig/compound-proof-verification.test.mjs

@@ -1,11 +1,11 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
-import { i as verifyMapLocalProof, s as verifyPortableObjectProofPolicy } from "../proof-D3te0SP-.mjs";
-import { i as verifyCompoundProofDocuments, r as verifyCompoundPortableObjectProofs } from "../compound-proof-7UIAueLV.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { i as verifyMapLocalProof, s as verifyPortableObjectProofPolicy } from "../proof-BVxJu5vv.mjs";
+import { a as verifyCompoundPortableObjectProofs, o as verifyCompoundProofDocuments } from "../compound-proof-BIvUoJxm.mjs";
 import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
 import { t as map_local_context_conflict_default } from "../map-local-context-conflict-DOYEEJ3u.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/sig/compound-proof.test.mjs

@@ -1,16 +1,17 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { n as ed25519PrivateKey, r as ed25519PublicKey } from "../keys-DIJNHW-Y.mjs";
-import { n as preloadedOnlyDocumentLoader } from "../public-audience-Cc2YJ3ip.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-B5Ne7JoL.mjs";
-import { c as verifyProof, r as signObject } from "../proof-D3te0SP-.mjs";
+import { n as preloadedOnlyDocumentLoader } from "../public-audience--klBIOk1.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
+import { c as verifyProof, r as signObject } from "../proof-BVxJu5vv.mjs";
+import { o as verifyCompoundProofDocuments } from "../compound-proof-BIvUoJxm.mjs";
 import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
 import { t as map_local_context_conflict_default } from "../map-local-context-conflict-DOYEEJ3u.mjs";
-import { Create, DataIntegrityProof, Note } from "@fedify/vocab";
+import { Create, DataIntegrityProof, Note, Question } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { encodeMultibase, exportDidKey, parseIri } from "@fedify/vocab-runtime";
 import { encodeHex } from "byte-encodings/hex";
@@ -46,6 +47,16 @@ const options = {
 	contextLoader: mockDocumentLoader,
 	documentLoader: mockDocumentLoader
 };
+const inboundOptions = {
+	contextLoader: preloadedOnlyDocumentLoader,
+	documentLoader: preloadedOnlyDocumentLoader
+};
+const compoundLimits = {
+	maxDepth: 16,
+	maxMaps: 32,
+	maxProofs: 8,
+	maxBytes: 16384
+};
 async function parseProof(document) {
 	const proof = document.proof;
 	assert(proof != null && typeof proof === "object" && !Array.isArray(proof));
@@ -171,10 +182,6 @@ test("the context-conflict vector records valid proofs and divergent semantics",
 		hashes: map_local_context_conflict_default.hashes.inner,
 		proofValue: map_local_context_conflict_default.proofValues.inner
 	});
-	const inboundOptions = {
-		contextLoader: preloadedOnlyDocumentLoader,
-		documentLoader: preloadedOnlyDocumentLoader
-	};
 	const verifiedInner = await verifyProof(embedded, await parseProof(embedded), inboundOptions);
 	assertEquals(verifiedInner != null, map_local_context_conflict_default.expectedVerification.original.inner);
 	assertEquals(verifiedInner?.id, conflictVectorInnerKeyId);
@@ -226,10 +233,9 @@ test("the raw same-context baseline verifies map-locally", async () => {
 	assertEquals(replacementInnerKey?.id, vectorInnerKeyId);
 	assertEquals(await verifyProof(replaced, await parseProof(replaced), options) != null, map_local_create_note_default.expectedVerification.replacedInnerProof.outer);
 });
-test("typed Create serialization bypasses a parsed child's JSON-LD cache", async () => {
-	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
-	const inner = await signObject(new Note({
-		id: parseIri(`ap+ef61://${innerDid}/objects/distinct-context`),
+async function signDistinctContextNote(created, path) {
+	return await signObject(new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/${path}`),
 		attribution: parseIri(`ap+ef61://${innerDid}/actor`),
 		content: "A portable note with its own context"
 	}), ed25519PrivateKey, innerKeyId, {
@@ -237,65 +243,131 @@ test("typed Create serialization bypasses a parsed child's JSON-LD cache", async
 		context: distinctInnerContext,
 		created
 	});
-	const standaloneInner = await normalizeOutgoingActivityJsonLd(await inner.toJsonLd({
+}
+async function serializeOutgoing(object, context) {
+	return await normalizeOutgoingActivityJsonLd(await object.toJsonLd({
 		format: "compact",
 		...options,
-		context: distinctInnerContext
-	}), mockDocumentLoader);
-	const compound = await normalizeOutgoingActivityJsonLd(await (await signObject(new Create({
-		id: parseIri(`ap+ef61://${outerDid}/activities/distinct-context`),
+		context: context ?? options.context
+	}), mockDocumentLoader, { preserveNestedSecuredDocuments: true });
+}
+async function signOuterCreate(created, path, child) {
+	return await signObject(new Create({
+		id: parseIri(`ap+ef61://${outerDid}/activities/${path}`),
 		actor: parseIri(`ap+ef61://${outerDid}/actor`),
-		object: inner
+		object: child
 	}), outerPrivateKey, outerKeyId, {
 		...options,
 		created
-	})).toJsonLd({
-		format: "compact",
-		...options
-	}), mockDocumentLoader);
+	});
+}
+test("typed Create serialization embeds the signed child representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "distinct-context");
+	assert(inner instanceof Note);
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const outer = await signOuterCreate(created, "distinct-context", inner);
+	assert(outer instanceof Create);
+	const compound = await serializeOutgoing(outer);
 	const embedded = compound.object;
 	const embeddedProof = embedded.proof;
-	const standaloneProof = await parseProof(standaloneInner);
-	assertEquals(standaloneInner["@context"], distinctInnerContext);
-	assertEquals(standaloneInner.proof["@context"], distinctInnerContext);
-	assertEquals(embedded["@context"], void 0);
-	assertEquals(embeddedProof["@context"], void 0);
-	assertEquals(embeddedProof.proofValue, standaloneInner.proof.proofValue);
-	const compactedStandalone = structuredClone(standaloneInner);
-	const compactedStandaloneProof = compactedStandalone.proof;
-	delete compactedStandalone["@context"];
-	delete compactedStandaloneProof["@context"];
-	assertEquals(embedded, compactedStandalone);
-	assertEquals((await verifyProof(standaloneInner, standaloneProof, options))?.id, innerKeyId);
-	const rewrittenContext = structuredClone(standaloneInner);
-	rewrittenContext["@context"] = context;
-	assertEquals(await verifyProof(rewrittenContext, standaloneProof, options), null);
-	assertEquals(await verifyProof(embedded, standaloneProof, options), null);
+	assertEquals(embedded["@context"], distinctInnerContext);
+	assertEquals(embeddedProof["@context"], distinctInnerContext);
+	assertEquals(compound["@context"], context);
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals(embedded.type, "Note");
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
 	assertEquals((await verifyProof(compound, await parseProof(compound), options))?.id, outerKeyId);
+	const mapLocal = await verifyCompoundProofDocuments(compound, compoundLimits, inboundOptions);
+	assertEquals(mapLocal.status, "ok");
+	assert(mapLocal.status === "ok");
+	assert(mapLocal.verified);
+	assertEquals(mapLocal.documents.map(({ path, verified }) => ({
+		path,
+		verified
+	})), [{
+		path: "/object",
+		verified: true
+	}, {
+		path: "",
+		verified: true
+	}]);
+});
+test("tampering with an embedded signed child invalidates both proofs", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const tampered = await serializeOutgoing(await signOuterCreate(created, "tampered", await signDistinctContextNote(created, "tampered")));
+	const tamperedInner = tampered.object;
+	tamperedInner.content = "A tampered portable note";
+	assertEquals(await verifyProof(tamperedInner, await parseProof(tamperedInner), options), null);
+	assertEquals(await verifyProof(tampered, await parseProof(tampered), options), null);
+});
+test("replacing an embedded child proof invalidates only the outer proof", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const replacementCreated = Temporal.Instant.from("2023-02-25T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "replaced-proof");
+	const replacementProof = (await serializeOutgoing(await signDistinctContextNote(replacementCreated, "replaced-proof"), distinctInnerContext)).proof;
+	const compound = await serializeOutgoing(await signOuterCreate(created, "replaced-proof", inner));
+	const replacedInner = compound.object;
+	replacedInner.proof = replacementProof;
+	assertEquals((await verifyProof(replacedInner, await parseProof(replacedInner), options))?.id, innerKeyId);
+	assertEquals(await verifyProof(compound, await parseProof(compound), options), null);
+});
+test("cloning or re-signing a signed child drops its retained representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "cloned");
+	const cloned = inner.clone({});
+	assert(cloned instanceof Note);
+	const clonedEmbedded = (await serializeOutgoing(await signOuterCreate(created, "cloned", cloned))).object;
+	assertEquals(clonedEmbedded["@context"], void 0);
+	assertEquals(clonedEmbedded.proof["@context"], void 0);
+	const reSignedEmbedded = (await serializeOutgoing(await signOuterCreate(created, "re-signed", await signObject(inner, ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	})))).object;
+	assertEquals(reSignedEmbedded["@context"], void 0);
+});
+test("mutating a signed child does not change its embedded representation", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const inner = await signDistinctContextNote(created, "mutated");
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const proof = (await Array.fromAsync(inner.getProofs(options)))[0];
+	assert(proof.proofValue != null);
+	proof.proofValue[0] ^= 255;
+	const embedded = (await serializeOutgoing(await signOuterCreate(created, "mutated", inner))).object;
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
+});
+test("a signed child is embedded through a compactable ancestor too", async () => {
+	const inner = await signDistinctContextNote(Temporal.Instant.from("2023-02-24T23:36:38Z"), "compactable-parent");
+	const standaloneInner = await serializeOutgoing(inner, distinctInnerContext);
+	const wrapper = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/wrapper`),
+		attachments: [inner]
+	});
+	const embedded = (await new Question({
+		id: parseIri(`ap+ef61://${outerDid}/objects/question`),
+		exclusiveOptions: [wrapper]
+	}).toJsonLd()).oneOf.attachment;
+	assertEquals(serialize(embedded), serialize(standaloneInner));
+	assertEquals((await verifyProof(embedded, await parseProof(embedded), options))?.id, innerKeyId);
+});
+test("typed Create serialization bypasses a parsed child's JSON-LD cache", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	const standaloneInner = await serializeOutgoing(await signDistinctContextNote(created, "reparsed-context"), distinctInnerContext);
+	const standaloneProof = await parseProof(standaloneInner);
 	const reparsedInner = await Note.fromJsonLd(standaloneInner, {
 		contextLoader: mockDocumentLoader,
 		documentLoader: mockDocumentLoader
 	});
 	assert(reparsedInner instanceof Note);
 	assertEquals(await reparsedInner.toJsonLd(), standaloneInner);
-	const reparsedCompound = await normalizeOutgoingActivityJsonLd(await (await signObject(new Create({
-		id: parseIri(`ap+ef61://${outerDid}/activities/reparsed-context`),
-		actor: parseIri(`ap+ef61://${outerDid}/actor`),
-		object: reparsedInner
-	}), outerPrivateKey, outerKeyId, {
-		...options,
-		created
-	})).toJsonLd({
-		format: "compact",
-		...options
-	}), mockDocumentLoader);
+	const reparsedCompound = await serializeOutgoing(await signOuterCreate(created, "reparsed-context", reparsedInner));
 	const reparsedEmbedded = reparsedCompound.object;
 	const reparsedEmbeddedProof = reparsedEmbedded.proof;
 	assertEquals(reparsedEmbedded["@context"], void 0);
 	assertEquals(reparsedEmbeddedProof["@context"], void 0);
 	assertEquals(reparsedEmbeddedProof.proofValue, standaloneInner.proof.proofValue);
-	assertEquals(reparsedEmbedded, compactedStandalone);
-	assertEquals(reparsedEmbedded, embedded);
 	assertEquals(await verifyProof(reparsedEmbedded, standaloneProof, options), null);
 	assertEquals((await verifyProof(reparsedCompound, await parseProof(reparsedCompound), options))?.id, outerKeyId);
 });
@@ -305,10 +377,6 @@ test("verifyProof() does not invent a missing child context", async () => {
 	const receivedInnerProof = receivedInner.proof;
 	delete receivedInner["@context"];
 	delete receivedInnerProof["@context"];
-	const inboundOptions = {
-		contextLoader: preloadedOnlyDocumentLoader,
-		documentLoader: preloadedOnlyDocumentLoader
-	};
 	const snapshot = structuredClone(received);
 	const proof = await DataIntegrityProof.fromJsonLd(received.proof, inboundOptions);
 	assertEquals(await verifyProof(received, proof, inboundOptions), null);
@@ -320,5 +388,24 @@ test("verifyProof() does not invent a missing child context", async () => {
 	guessedInnerProof["@context"] = structuredClone(guessed["@context"]);
 	assertEquals((await verifyProof(guessed, proof, inboundOptions))?.id, outerKeyId);
 });
+test("signing a document too deep to retain still succeeds", async () => {
+	const created = Temporal.Instant.from("2023-02-24T23:36:38Z");
+	let deep = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/deep-leaf`),
+		content: "A portable note nested past the retention bounds"
+	});
+	for (let i = 0; i < 40; i++) deep = new Note({
+		id: parseIri(`ap+ef61://${innerDid}/objects/deep-${i}`),
+		attachments: [deep]
+	});
+	const signed = await signObject(deep, ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	});
+	assertEquals((await Array.fromAsync(signed.getProofs(options))).length, 1);
+	const embedded = (await serializeOutgoing(await signOuterCreate(created, "deep", signed))).object;
+	assertEquals(embedded["@context"], void 0);
+});
 //#endregion
 export {};

package/dist/sig/http.test.mjs

@@ -2,16 +2,17 @@ import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
-import { l as AssertionError, t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { t as assertExists } from "../assert_exists-DtzkXC47.mjs";
-import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
-import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BApOTh1h.mjs";
-import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
-import { t as exportJwk } from "../key-zxzx01Ec.mjs";
-import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-DZaAutqg.mjs";
+import { t as AssertionError } from "../assertion_error-B-cx0fFA.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertExists } from "../assert_exists-cffSpJ7X.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
+import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { t as exportJwk } from "../key-B_Zc5Jbd.mjs";
+import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-D4WPcJUe.mjs";
 import { i as rsaPrivateKey2, l as rsaPublicKey5, o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, exportSpki } from "@fedify/vocab-runtime";

package/dist/sig/key.test.mjs

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
-import { a as generateCryptoKeyPair, i as fetchKeyDetailed, o as importJwk, r as fetchKey, s as validateCryptoKey, t as exportJwk } from "../key-zxzx01Ec.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { a as generateCryptoKeyPair, i as fetchKeyDetailed, o as importJwk, r as fetchKey, s as validateCryptoKey, t as exportJwk } from "../key-B_Zc5Jbd.mjs";
 import { c as rsaPublicKey3, i as rsaPrivateKey2, o as rsaPublicKey1, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";

package/dist/sig/ld.test.mjs

@@ -1,16 +1,16 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
-import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BApOTh1h.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-g3WcyYNR.mjs";
-import { t as assertThrows } from "../assert_throws-BJ5wuvR2.mjs";
-import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
-import { a as generateCryptoKeyPair } from "../key-zxzx01Ec.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
+import { a as generateCryptoKeyPair } from "../key-B_Zc5Jbd.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { a as compactJsonLd, f as isInvalidUrlTypeError, g as verifySignature, h as verifyJsonLd, i as attachSignature, n as UnsafeJsonLdError, o as createSignature, p as signJsonLd, s as detachSignature, u as hasSignatureLike } from "../ld-CD_TN0e8.mjs";
+import { a as compactJsonLd, f as isInvalidUrlTypeError, g as verifySignature, h as verifyJsonLd, i as attachSignature, n as UnsafeJsonLdError, o as createSignature, p as signJsonLd, s as detachSignature, u as hasSignatureLike } from "../ld-B16KUSIQ.mjs";
 import { CryptographicKey } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { encodeBase64 } from "byte-encodings/base64";

package/dist/sig/mod.cjs

@@ -1,7 +1,7 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http = require("../http-DQBfmkrS.cjs");
-const require_owner = require("../owner--mNatWct.cjs");
+const require_http = require("../http-B5F1JMh0.cjs");
+const require_owner = require("../owner-WUYke16i.cjs");
 exports.attachSignature = require_owner.attachSignature;
 exports.createProof = require_owner.createProof;
 exports.createSignature = require_owner.createSignature;

package/dist/sig/mod.d.cts

@@ -1,5 +1,5 @@
 /// <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-CP-7OdSq.cjs";
 import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-BF0L9cMt.cjs";
-import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-CbKDOnCt.cjs";
+import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-CVQFWefn.cjs";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyPortableObjectProofFailureReason, VerifyPortableObjectProofOptions, VerifyPortableObjectProofResult, 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, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/mod.d.ts

@@ -1,5 +1,5 @@
 /// <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-65PYi9jY.js";
 import { i as getKeyOwner, n as GetKeyOwnerOptions, r as doesActorOwnKey, t as DoesActorOwnKeyOptions } from "../owner-BSzr5-I8.js";
-import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-UDwMjuHM.js";
+import { C as verifyJsonLd, S as signJsonLd, _ as VerifySignatureOptions, a as VerifyPortableObjectProofOptions, b as detachSignature, c as createProof, d as verifyObject, f as verifyPortableObjectProof, g as VerifyJsonLdOptions, h as SignJsonLdOptions, i as VerifyPortableObjectProofFailureReason, l as hasProofLike, m as CreateSignatureOptions, n as SignObjectOptions, o as VerifyPortableObjectProofResult, p as verifyProof, r as VerifyObjectOptions, s as VerifyProofOptions, t as CreateProofOptions, u as signObject, v as attachSignature, w as verifySignature, x as hasSignatureLike, y as createSignature } from "../mod-CNRAxXEb.js";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyPortableObjectProofFailureReason, VerifyPortableObjectProofOptions, VerifyPortableObjectProofResult, 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, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/mod.js

@@ -1,5 +1,5 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { F as validateAcceptSignature, M as formatAcceptSignature, N as fulfillAcceptSignature, P as parseAcceptSignature, a as verifyRequestDetailed, c as fetchKey, d as importJwk, i as verifyRequest, l as fetchKeyDetailed, o as exportJwk, r as signRequest, u as generateCryptoKeyPair } from "../http-DQA2JOEJ.js";
-import { S as signJsonLd, T as verifySignature, a as signObject, c as verifyPortableObjectProof, g as detachSignature, h as createSignature, i as hasProofLike, n as getKeyOwner, p as attachSignature, r as createProof, s as verifyObject, t as doesActorOwnKey, u as verifyProof, w as verifyJsonLd, y as hasSignatureLike } from "../owner-BNKC3s6G.js";
+import { F as validateAcceptSignature, M as formatAcceptSignature, N as fulfillAcceptSignature, P as parseAcceptSignature, a as verifyRequestDetailed, c as fetchKey, d as importJwk, i as verifyRequest, l as fetchKeyDetailed, o as exportJwk, r as signRequest, u as generateCryptoKeyPair } from "../http-By8tnmEr.js";
+import { S as signJsonLd, T as verifySignature, a as signObject, c as verifyPortableObjectProof, g as detachSignature, h as createSignature, i as hasProofLike, n as getKeyOwner, p as attachSignature, r as createProof, s as verifyObject, t as doesActorOwnKey, u as verifyProof, w as verifyJsonLd, y as hasSignatureLike } from "../owner-D-E0bT2O.js";
 export { attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/owner.test.mjs

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-u3IJRhVx.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-BIOIhZoM.mjs";
 import { Create, CryptographicKey, lookupObject } from "@fedify/vocab";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/sig/owner.test.ts

package/dist/sig/proof.test.mjs

@@ -1,16 +1,16 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
-import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BApOTh1h.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-g3WcyYNR.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { t as assert } from "../assert-CebeUf0C.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { t as assertFalse } from "../assert_false-CPdRnc3E.mjs";
+import { t as assertGreaterOrEqual } from "../assert_greater_or_equal-BlafOF4-.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { t as assert } from "../assert-D1Eafmd_.mjs";
 import { i as rsaPrivateKey2, n as ed25519PrivateKey, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-B5Ne7JoL.mjs";
-import { a as verifyObject, c as verifyProof, n as hasProofLike, o as verifyPortableObjectProof, r as signObject, t as createProof } from "../proof-D3te0SP-.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "../outgoing-jsonld-4IJqPYos.mjs";
+import { a as verifyObject, c as verifyProof, n as hasProofLike, o as verifyPortableObjectProof, r as signObject, t as createProof } from "../proof-BVxJu5vv.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/std__assert-DvMDRPes.mjs

@@ -0,0 +1,8 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import "./assert_equals-Z6IcEbWU.mjs";
+import "./assert_throws-BYITOvPO.mjs";
+import "./assert_rejects-CTptdYck.mjs";
+import "./assert_strict_equals-CYvBmkpC.mjs";
+export {};

package/dist/{temporal-DKhVF_Uk.mjs → temporal-CCf0lZV3.mjs}

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

package/dist/testing/kv.test.mjs

@@ -5,8 +5,8 @@ import { n as test } from "../dist-BQvArojP.mjs";
 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-CBlRfA-_.mjs";
-import { o as createFederation } from "../middleware-pHwDTAnq.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import { o as createFederation } from "../middleware-C7_hqDnl.mjs";
 //#region src/testing/kv.test.ts
 test("ManualClockKvStore keeps an entry at its exact expiration instant", async () => {
 	const kv = new ManualClockKvStore();

package/dist/utils/docloader.test.mjs

@@ -2,12 +2,12 @@ import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "../esm-BHXXx4Wx.mjs";
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
-import { l as verifyRequest } from "../http-DZaAutqg.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
+import { l as verifyRequest } from "../http-D4WPcJUe.mjs";
 import { i as rsaPrivateKey2 } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-DUKEPG-O.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-qUudHZVH.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";
 //#region src/utils/docloader.test.ts