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

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

@@ -0,0 +1,324 @@
+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 { 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 { 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 { mockDocumentLoader, test } from "@fedify/fixture";
+import { encodeMultibase, exportDidKey, parseIri } from "@fedify/vocab-runtime";
+import { encodeHex } from "byte-encodings/hex";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+import serialize from "json-canon";
+//#region src/sig/compound-proof.test.ts
+const outerPrivateKey = await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	d: "yW756hDF5BTEcXI6_53nLDX6W3D66X6IMuysfS4rjtY",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["sign"],
+	ext: true
+}, "Ed25519", true, ["sign"]);
+const outerDid = await exportDidKey(await crypto.subtle.importKey("jwk", {
+	kty: "OKP",
+	crv: "Ed25519",
+	x: "sA2Nk45_dz1RVlqtNqYj9TRPf10ZYPnPPo4SYg6igQ8",
+	key_ops: ["verify"],
+	ext: true
+}, "Ed25519", true, ["verify"]));
+const innerDid = await exportDidKey(ed25519PublicKey.publicKey);
+const outerMethod = outerDid.substring(8);
+const innerMethod = innerDid.substring(8);
+const outerKeyId = new URL(`${outerDid}#${outerMethod}`);
+const innerKeyId = new URL(`${innerDid}#${innerMethod}`);
+const vectorInnerKeyId = new URL(map_local_create_note_default.keys.inner.verificationMethod);
+const conflictVectorInnerKeyId = new URL(map_local_context_conflict_default.keys.inner.verificationMethod);
+const context = ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/data-integrity/v1"];
+const distinctInnerContext = [...context, { ex: "https://example.com/ns#" }];
+const options = {
+	context,
+	contextLoader: mockDocumentLoader,
+	documentLoader: mockDocumentLoader
+};
+async function parseProof(document) {
+	const proof = document.proof;
+	assert(proof != null && typeof proof === "object" && !Array.isArray(proof));
+	return await DataIntegrityProof.fromJsonLd({
+		"@context": document["@context"],
+		...proof
+	}, options);
+}
+function asRecord(value) {
+	assert(value != null && typeof value === "object" && !Array.isArray(value));
+	return value;
+}
+function withoutDirectProof(document) {
+	const unsecuredDocument = structuredClone(document);
+	delete unsecuredDocument.proof;
+	return unsecuredDocument;
+}
+function withoutProofValue(proof) {
+	const proofConfiguration = structuredClone(proof);
+	delete proofConfiguration.proofValue;
+	return proofConfiguration;
+}
+async function sha256(value) {
+	return new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)));
+}
+async function assertRecordedProof(entry) {
+	assertEquals(withoutProofValue(entry.proof), entry.proofConfiguration);
+	assertEquals(entry.proof.proofValue, entry.proofValue);
+	const documentJcs = serialize(entry.document);
+	const proofConfigurationJcs = serialize(entry.proofConfiguration);
+	assertEquals(documentJcs, entry.canonicalization.documentJcs);
+	assertEquals(proofConfigurationJcs, entry.canonicalization.proofConfigurationJcs);
+	const documentDigest = await sha256(documentJcs);
+	const proofConfigurationDigest = await sha256(proofConfigurationJcs);
+	assertEquals(encodeHex(documentDigest), entry.hashes.documentSha256);
+	assertEquals(encodeHex(proofConfigurationDigest), entry.hashes.proofConfigurationSha256);
+	const combinedSigningInput = new Uint8Array(proofConfigurationDigest.length + documentDigest.length);
+	combinedSigningInput.set(proofConfigurationDigest);
+	combinedSigningInput.set(documentDigest, proofConfigurationDigest.length);
+	assertEquals(encodeHex(combinedSigningInput), entry.hashes.combinedSigningInput);
+	assertEquals(entry.hashes.combinedSigningInput, entry.hashes.proofConfigurationSha256 + entry.hashes.documentSha256);
+	const privateJwk = structuredClone(entry.key.testPrivateKeyJwk);
+	const publicJwk = structuredClone(entry.key.publicKeyJwk);
+	assertEquals(privateJwk.x, publicJwk.x);
+	const privateKey = await crypto.subtle.importKey("jwk", privateJwk, "Ed25519", true, ["sign"]);
+	const publicKey = await crypto.subtle.importKey("jwk", publicJwk, "Ed25519", true, ["verify"]);
+	const controller = await exportDidKey(publicKey);
+	assertEquals(controller, entry.key.controller);
+	const publicKeyMultibase = controller.replace(/^did:key:/, "");
+	assertEquals(publicKeyMultibase, entry.key.publicKeyMultibase);
+	assertEquals(entry.key.verificationMethod, `${controller}#${publicKeyMultibase}`);
+	assertEquals(entry.proofConfiguration.verificationMethod, entry.key.verificationMethod);
+	const signature = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, combinedSigningInput));
+	assert(await crypto.subtle.verify("Ed25519", publicKey, signature, combinedSigningInput));
+	assertEquals(new TextDecoder().decode(encodeMultibase("base58btc", signature)), entry.proofValue);
+}
+test("map-local compound vector records independently reproducible proofs", async () => {
+	const securedOuter = asRecord(map_local_create_note_default.documents.finalSecuredCompound);
+	const securedInner = asRecord(map_local_create_note_default.documents.securedInner);
+	const outerProof = asRecord(securedOuter.proof);
+	const innerProof = asRecord(securedInner.proof);
+	const replacementInnerProof = asRecord(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerProofConfiguration = withoutProofValue(replacementInnerProof);
+	assertEquals(withoutDirectProof(securedOuter), map_local_create_note_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(securedInner), map_local_create_note_default.documents.innerUnsecuredDocument);
+	assertEquals(withoutProofValue(outerProof), map_local_create_note_default.documents.outerProofConfiguration);
+	assertEquals(withoutProofValue(innerProof), map_local_create_note_default.documents.innerProofConfiguration);
+	const entries = [
+		{
+			document: map_local_create_note_default.documents.outerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.outerProofConfiguration,
+			proof: outerProof,
+			key: map_local_create_note_default.keys.outer,
+			canonicalization: map_local_create_note_default.canonicalization.outer,
+			hashes: map_local_create_note_default.hashes.outer,
+			proofValue: map_local_create_note_default.proofValues.outer
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: map_local_create_note_default.documents.innerProofConfiguration,
+			proof: innerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.inner,
+			hashes: map_local_create_note_default.hashes.inner,
+			proofValue: map_local_create_note_default.proofValues.inner
+		},
+		{
+			document: map_local_create_note_default.documents.innerUnsecuredDocument,
+			proofConfiguration: replacementInnerProofConfiguration,
+			proof: replacementInnerProof,
+			key: map_local_create_note_default.keys.inner,
+			canonicalization: map_local_create_note_default.canonicalization.replacementInner,
+			hashes: map_local_create_note_default.hashes.replacementInner,
+			proofValue: map_local_create_note_default.proofValues.replacementInner
+		}
+	];
+	for (const entry of entries) await assertRecordedProof(entry);
+});
+test("the context-conflict vector records valid proofs and divergent semantics", async () => {
+	const compound = asRecord(map_local_context_conflict_default.documents.finalSecuredCompound);
+	const embedded = asRecord(compound.object);
+	const securedInner = asRecord(map_local_context_conflict_default.documents.securedInner);
+	const outerProof = asRecord(compound.proof);
+	const innerProof = asRecord(embedded.proof);
+	assertEquals(embedded, securedInner);
+	assertEquals(withoutDirectProof(compound), map_local_context_conflict_default.documents.outerUnsecuredDocument);
+	assertEquals(withoutDirectProof(embedded), map_local_context_conflict_default.documents.innerUnsecuredDocument);
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.outerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.outerProofConfiguration,
+		proof: outerProof,
+		key: map_local_context_conflict_default.keys.outer,
+		canonicalization: map_local_context_conflict_default.canonicalization.outer,
+		hashes: map_local_context_conflict_default.hashes.outer,
+		proofValue: map_local_context_conflict_default.proofValues.outer
+	});
+	await assertRecordedProof({
+		document: map_local_context_conflict_default.documents.innerUnsecuredDocument,
+		proofConfiguration: map_local_context_conflict_default.documents.innerProofConfiguration,
+		proof: innerProof,
+		key: map_local_context_conflict_default.keys.inner,
+		canonicalization: map_local_context_conflict_default.canonicalization.inner,
+		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);
+	const verifiedOuter = await verifyProof(compound, await parseProof(compound), inboundOptions);
+	assertEquals(verifiedOuter != null, map_local_context_conflict_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuter?.id, outerKeyId);
+	const standaloneExpansion = await jsonld.expand(embedded, { documentLoader: preloadedOnlyDocumentLoader });
+	const compoundExpansion = await jsonld.expand(compound, { documentLoader: preloadedOnlyDocumentLoader });
+	const content = "https://www.w3.org/ns/activitystreams#content";
+	const object = "https://www.w3.org/ns/activitystreams#object";
+	const standaloneContent = asRecord(standaloneExpansion[0])[content];
+	const inParentObject = asRecord(asRecord(compoundExpansion[0])[object][0]);
+	const inParentContent = inParentObject[content];
+	assertEquals(serialize(standaloneExpansion[0]) === serialize(inParentObject), map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+	assertEquals(standaloneContent, [{ "@value": "A portable note with inherited language" }]);
+	assertEquals(inParentContent, [{
+		"@value": "A portable note with inherited language",
+		"@language": map_local_context_conflict_default.expectedInterpretation.inParentContentLanguage
+	}]);
+	assertEquals(standaloneContent[0]["@language"] ?? null, map_local_context_conflict_default.expectedInterpretation.standaloneContentLanguage);
+	assertEquals(serialize(standaloneContent) !== serialize(inParentContent), !map_local_context_conflict_default.expectedInterpretation.standaloneAndInParentExpansionsEqual);
+});
+test("the raw same-context baseline verifies map-locally", async () => {
+	const compound = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const embedded = compound.object;
+	const embeddedProof = embedded.proof;
+	assertEquals(embedded, map_local_create_note_default.documents.securedInner);
+	assertEquals(embeddedProof["@context"], context);
+	assertEquals(embedded["@context"], context);
+	assert("proof" in embedded);
+	const verifiedInnerKey = await verifyProof(embedded, await parseProof(embedded), options);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.original.inner);
+	assertEquals(verifiedInnerKey != null, map_local_create_note_default.expectedVerification.standaloneInner);
+	assertEquals(verifiedInnerKey?.id, vectorInnerKeyId);
+	const verifiedOuterKey = await verifyProof(compound, await parseProof(compound), options);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.original.outer);
+	assertEquals(verifiedOuterKey != null, map_local_create_note_default.expectedVerification.standaloneOuter);
+	assertEquals(verifiedOuterKey?.id, outerKeyId);
+	const tampered = structuredClone(compound);
+	const tamperedInner = tampered.object;
+	tamperedInner.content = "A tampered portable note";
+	assertEquals(await verifyProof(tamperedInner, await parseProof(tamperedInner), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.inner);
+	assertEquals(await verifyProof(tampered, await parseProof(tampered), options) != null, map_local_create_note_default.expectedVerification.tamperedInnerContent.outer);
+	const replaced = structuredClone(compound);
+	const replacedInner = replaced.object;
+	replacedInner.proof = structuredClone(map_local_create_note_default.documents.replacementInnerProof);
+	const replacementInnerKey = await verifyProof(replacedInner, await parseProof(replacedInner), options);
+	assertEquals(replacementInnerKey != null, map_local_create_note_default.expectedVerification.replacedInnerProof.inner);
+	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`),
+		attribution: parseIri(`ap+ef61://${innerDid}/actor`),
+		content: "A portable note with its own context"
+	}), ed25519PrivateKey, innerKeyId, {
+		...options,
+		context: distinctInnerContext,
+		created
+	});
+	const standaloneInner = await normalizeOutgoingActivityJsonLd(await inner.toJsonLd({
+		format: "compact",
+		...options,
+		context: distinctInnerContext
+	}), mockDocumentLoader);
+	const compound = await normalizeOutgoingActivityJsonLd(await (await signObject(new Create({
+		id: parseIri(`ap+ef61://${outerDid}/activities/distinct-context`),
+		actor: parseIri(`ap+ef61://${outerDid}/actor`),
+		object: inner
+	}), outerPrivateKey, outerKeyId, {
+		...options,
+		created
+	})).toJsonLd({
+		format: "compact",
+		...options
+	}), mockDocumentLoader);
+	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((await verifyProof(compound, await parseProof(compound), options))?.id, outerKeyId);
+	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 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);
+});
+test("verifyProof() does not invent a missing child context", async () => {
+	const received = structuredClone(map_local_create_note_default.documents.finalSecuredCompound);
+	const receivedInner = received.object;
+	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);
+	assertEquals(received, snapshot);
+	const guessed = structuredClone(received);
+	const guessedInner = guessed.object;
+	const guessedInnerProof = guessedInner.proof;
+	guessedInner["@context"] = structuredClone(guessed["@context"]);
+	guessedInnerProof["@context"] = structuredClone(guessed["@context"]);
+	assertEquals((await verifyProof(guessed, proof, inboundOptions))?.id, outerKeyId);
+});
+//#endregion
+export {};

package/dist/sig/http.test.mjs

@@ -10,8 +10,8 @@ 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-Cwbg5ggV.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-CtidZS_t.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 { 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

@@ -6,7 +6,7 @@ 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-Cwbg5ggV.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 { 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

@@ -8,9 +8,9 @@ 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-Cwbg5ggV.mjs";
+import { a as generateCryptoKeyPair } from "../key-zxzx01Ec.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-CzhdWyTt.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 { CryptographicKey } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { encodeBase64 } from "byte-encodings/base64";

package/dist/sig/mod.cjs

@@ -1,31 +1,31 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http = require("../http-Z3anvCd-.cjs");
-const require_proof = require("../proof-DHu5zI0Z.cjs");
-exports.attachSignature = require_proof.attachSignature;
-exports.createProof = require_proof.createProof;
-exports.createSignature = require_proof.createSignature;
-exports.detachSignature = require_proof.detachSignature;
-exports.doesActorOwnKey = require_proof.doesActorOwnKey;
+const require_http = require("../http-DQBfmkrS.cjs");
+const require_owner = require("../owner--mNatWct.cjs");
+exports.attachSignature = require_owner.attachSignature;
+exports.createProof = require_owner.createProof;
+exports.createSignature = require_owner.createSignature;
+exports.detachSignature = require_owner.detachSignature;
+exports.doesActorOwnKey = require_owner.doesActorOwnKey;
 exports.exportJwk = require_http.exportJwk;
 exports.fetchKey = require_http.fetchKey;
 exports.fetchKeyDetailed = require_http.fetchKeyDetailed;
 exports.formatAcceptSignature = require_http.formatAcceptSignature;
 exports.fulfillAcceptSignature = require_http.fulfillAcceptSignature;
 exports.generateCryptoKeyPair = require_http.generateCryptoKeyPair;
-exports.getKeyOwner = require_proof.getKeyOwner;
-exports.hasProofLike = require_proof.hasProofLike;
-exports.hasSignatureLike = require_proof.hasSignatureLike;
+exports.getKeyOwner = require_owner.getKeyOwner;
+exports.hasProofLike = require_owner.hasProofLike;
+exports.hasSignatureLike = require_owner.hasSignatureLike;
 exports.importJwk = require_http.importJwk;
 exports.parseAcceptSignature = require_http.parseAcceptSignature;
-exports.signJsonLd = require_proof.signJsonLd;
-exports.signObject = require_proof.signObject;
+exports.signJsonLd = require_owner.signJsonLd;
+exports.signObject = require_owner.signObject;
 exports.signRequest = require_http.signRequest;
 exports.validateAcceptSignature = require_http.validateAcceptSignature;
-exports.verifyJsonLd = require_proof.verifyJsonLd;
-exports.verifyObject = require_proof.verifyObject;
-exports.verifyPortableObjectProof = require_proof.verifyPortableObjectProof;
-exports.verifyProof = require_proof.verifyProof;
+exports.verifyJsonLd = require_owner.verifyJsonLd;
+exports.verifyObject = require_owner.verifyObject;
+exports.verifyPortableObjectProof = require_owner.verifyPortableObjectProof;
+exports.verifyProof = require_owner.verifyProof;
 exports.verifyRequest = require_http.verifyRequest;
 exports.verifyRequestDetailed = require_http.verifyRequestDetailed;
-exports.verifySignature = require_proof.verifySignature;
+exports.verifySignature = require_owner.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-CgwqtxAy.js";
-import { C as verifyJsonLd, a as verifyPortableObjectProof, c as doesActorOwnKey, f as attachSignature, h as detachSignature, i as verifyObject, l as getKeyOwner, m as createSignature, n as hasProofLike, o as verifyProof, r as signObject, t as createProof, v as hasSignatureLike, w as verifySignature, x as signJsonLd } from "../proof-CUghqhAf.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-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";
 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

@@ -6,7 +6,7 @@ import { t as assertFalse } from "../assert_false-3pLLLsO4.mjs";
 import "../std__assert-CxFT0MNt.mjs";
 import { t as assert } from "../assert-CebeUf0C.mjs";
 import { o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
-import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-BqVXJLW8.mjs";
+import { n as getKeyOwner, t as doesActorOwnKey } from "../owner-u3IJRhVx.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

@@ -10,7 +10,7 @@ import { t as assertRejects } from "../assert_rejects-wFbSPn1O.mjs";
 import { t as assert } from "../assert-CebeUf0C.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 verifyPortableObjectProof, i as verifyObject, n as hasProofLike, o as verifyProof, r as signObject, t as createProof } from "../proof-DL8Iid3a.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 { Create, DataIntegrityProof, Document, Multikey, Note, PUBLIC_COLLECTION, Place, Translation } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { decodeMultibase, encodeMultibase, exportDidKey, exportMultibaseKey, formatIri, importMultibaseKey, parseIri } from "@fedify/vocab-runtime";

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

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

package/dist/testing/kv.test.mjs

@@ -6,7 +6,7 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as ManualClockKvStore } from "../kv-DBRWVx3Q.mjs";
 import { n as baseOptions, o as stringSchema, t as MockQueue } from "../tasks-dbCShlCb.mjs";
 import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import { o as createFederation } from "../middleware-DCpiAsZi.mjs";
+import { o as createFederation } from "../middleware-pHwDTAnq.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

@@ -5,9 +5,9 @@ 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-CtidZS_t.mjs";
+import { l as verifyRequest } from "../http-DZaAutqg.mjs";
 import { i as rsaPrivateKey2 } from "../keys-DIJNHW-Y.mjs";
-import { t as getAuthenticatedDocumentLoader } from "../docloader-DEYs99FZ.mjs";
+import { t as getAuthenticatedDocumentLoader } from "../docloader-DUKEPG-O.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError } from "@fedify/vocab-runtime";
 //#region src/utils/docloader.test.ts

package/dist/utils/kv-cache.test.mjs

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as kvCache, t as MockKvStore } from "../kv-cache-DHiR8yTf.mjs";
+import { n as kvCache, t as MockKvStore } from "../kv-cache-CbrUX90H.mjs";
 import { deepStrictEqual, throws } from "node:assert";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { preloadedContexts } from "@fedify/vocab-runtime";

package/dist/utils/mod.cjs

@@ -1,5 +1,5 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_kv_cache = require("../kv-cache-BM2-w-Wq.cjs");
+const require_kv_cache = require("../kv-cache-sy8OMNT8.cjs");
 exports.getAuthenticatedDocumentLoader = require_kv_cache.getAuthenticatedDocumentLoader;
 exports.kvCache = require_kv_cache.kvCache;

package/dist/utils/mod.js

@@ -1,4 +1,4 @@
 import { Temporal } from "temporal-polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-CykuL0ya.js";
+import { n as getAuthenticatedDocumentLoader, t as kvCache } from "../kv-cache-BBoePTOJ.js";
 export { getAuthenticatedDocumentLoader, kvCache };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/fedify",
-  "version": "2.4.0-dev.1988+c5c9d617",
+  "version": "2.4.0-dev.2010+498229f4",
   "description": "An ActivityPub server framework",
   "keywords": [
     "ActivityPub",
@@ -151,10 +151,10 @@
     "structured-field-values": "^2.0.4",
     "temporal-polyfill": "^1.0.1",
     "urlpattern-polyfill": "^10.1.0",
-    "@fedify/uri-template": "2.4.0-dev.1988+c5c9d617",
-    "@fedify/vocab": "2.4.0-dev.1988+c5c9d617",
-    "@fedify/vocab-runtime": "2.4.0-dev.1988+c5c9d617",
-    "@fedify/webfinger": "2.4.0-dev.1988+c5c9d617"
+    "@fedify/uri-template": "2.4.0-dev.2010+498229f4",
+    "@fedify/vocab": "2.4.0-dev.2010+498229f4",
+    "@fedify/webfinger": "2.4.0-dev.2010+498229f4",
+    "@fedify/vocab-runtime": "2.4.0-dev.2010+498229f4"
   },
   "devDependencies": {
     "@std/assert": "npm:@jsr/std__assert@^0.226.0",
@@ -167,7 +167,7 @@
     "typescript": "^6.0.0",
     "wrangler": "^4.17.0",
     "@fedify/fixture": "2.0.0",
-    "@fedify/vocab-tools": "^2.4.0-dev.1988+c5c9d617"
+    "@fedify/vocab-tools": "^2.4.0-dev.2010+498229f4"
   },
   "scripts": {
     "build:self": "tsdown",