@fedify/fedify 2.4.0-dev.1995 → 2.4.0-dev.2027

package/dist/{proof-BDxNVZ3E.mjs → proof-4ADU3qy0.mjs}

@@ -1,18 +1,19 @@
 import { Temporal } from "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-CABhzCb_.mjs";
-import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-CISXCvB1.mjs";
-import { r as fetchKey, s as validateCryptoKey } from "./key-Ccs8cnd7.mjs";
-import { n as preloadedOnlyDocumentLoader } from "./public-audience-Cc2YJ3ip.mjs";
-import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-B5Ne7JoL.mjs";
-import { c as getNormalizationContextLoader } from "./ld-qup__MAW.mjs";
+import { n as version, t as name } from "./deno-BcZNXlJn.mjs";
+import { n as getDurationMs, r as getFederationMetrics, s as measureSignatureKeyFetch } from "./metrics-D7RydU_p.mjs";
+import { r as fetchKey, s as validateCryptoKey } from "./key-Xb1hVVZO.mjs";
+import { n as preloadedOnlyDocumentLoader } from "./public-audience--klBIOk1.mjs";
+import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-4IJqPYos.mjs";
+import { c as getNormalizationContextLoader } from "./ld-DFHvxLtx.mjs";
 import { getLogger } from "@logtape/logtape";
 import { Activity, DataIntegrityProof, Multikey, getTypeId } from "@fedify/vocab";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
-import { formatIri, getDocumentLoader, getFe34Origin, haveSameFe34Origin, parseIri } from "@fedify/vocab-runtime";
+import { encodeMultibase, formatIri, getDocumentLoader, getFe34Origin, haveSameFe34Origin, parseIri } from "@fedify/vocab-runtime";
 import { encodeHex } from "byte-encodings/hex";
 import jsonld from "@fedify/vocab-runtime/jsonld";
+import { isPlainJsonTree, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";
 import serialize from "json-canon";
 //#region src/sig/proof.ts
 /**
@@ -68,17 +69,49 @@ function hasProofLike(jsonLd) {
 	};
 	return Array.isArray(proof) ? proof.some(isProofLike) : isProofLike(proof);
 }
+function isJsonMap(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
 /**
-* Creates a proof for the given object.
-* @param object The object to create a proof for.
-* @param privateKey The private key to sign the proof with.
-* @param keyId The key ID to use in the proof. It will be used by the verifier.
-* @param options Additional options.  See also {@link CreateProofOptions}.
-* @returns The created proof.
-* @throws {TypeError} If the private key is invalid or unsupported.
-* @since 0.10.0
+* Assembles the secured JSON document from the bytes that were just signed.
+*
+* The document is not re-derived from the vocabulary object: it is
+* `compactMsg`, the value whose JCS form was hashed, with the serialized
+* proof added.  Every part of it is then checked against the digests and the
+* signature that {@link createProofInternal} produced, so a document that is
+* returned verifies under the map-local compound-proof profile by
+* construction.  Anything that does not check out yields `null`, and the
+* caller simply does not retain a representation.
 */
-async function createProof(object, privateKey, keyId, { contextLoader, context, created } = {}) {
+async function captureSecuredDocument(proof, compactMsg, msgCanon, proofCanon, proofValue, contextLoader) {
+	if (!isJsonMap(compactMsg)) return null;
+	const documentContext = compactMsg["@context"];
+	if (documentContext == null) return null;
+	if (globalThis.Object.hasOwn(compactMsg, "proof")) return null;
+	try {
+		const proofJson = await proof.toJsonLd({
+			format: "compact",
+			contextLoader,
+			context: documentContext
+		});
+		if (!isJsonMap(proofJson)) return null;
+		const { proofValue: serializedProofValue, ...proofConfiguration } = proofJson;
+		if (serializedProofValue !== proofValue) return null;
+		if (serialize(proofConfiguration) !== proofCanon) return null;
+		const securedDocument = {
+			...structuredClone(compactMsg),
+			proof: structuredClone(proofJson)
+		};
+		const { proof: _embeddedProof, ...unsecuredDocument } = securedDocument;
+		if (serialize(unsecuredDocument) !== msgCanon) return null;
+		if (!isPlainJsonTree(securedDocument)) return null;
+		return securedDocument;
+	} catch (error) {
+		logger.debug("Failed to capture the secured JSON document for a created proof; the signed object will not preserve its representation when it is embedded in another object.\n{error}", { error });
+		return null;
+	}
+}
+async function createProofInternal(object, privateKey, keyId, { contextLoader, context, created } = {}, capture = false) {
 	validateCryptoKey(privateKey, "private");
 	if (privateKey.algorithm.name !== "Ed25519") throw new TypeError("Unsupported algorithm: " + privateKey.algorithm.name);
 	let compactMsg = await object.clone({ proofs: [] }).toJsonLd({
@@ -86,7 +119,7 @@ async function createProof(object, privateKey, keyId, { contextLoader, context,
 		contextLoader,
 		context
 	});
-	compactMsg = await normalizeOutgoingActivityJsonLd(compactMsg, contextLoader);
+	compactMsg = await normalizeOutgoingActivityJsonLd(compactMsg, contextLoader, { preserveNestedSecuredDocuments: true });
 	const msgCanon = serialize(compactMsg);
 	const encoder = new TextEncoder();
 	const msgBytes = encoder.encode(msgCanon);
@@ -105,14 +138,32 @@ async function createProof(object, privateKey, keyId, { contextLoader, context,
 	const digest = new Uint8Array(proofDigest.byteLength + msgDigest.byteLength);
 	digest.set(new Uint8Array(proofDigest), 0);
 	digest.set(new Uint8Array(msgDigest), proofDigest.byteLength);
-	const sig = await crypto.subtle.sign("Ed25519", privateKey, digest);
-	return new DataIntegrityProof({
+	const sig = new Uint8Array(await crypto.subtle.sign("Ed25519", privateKey, digest));
+	const proof = new DataIntegrityProof({
 		cryptosuite: "eddsa-jcs-2022",
 		verificationMethod: keyId,
 		proofPurpose: "assertionMethod",
-		created: created ?? Temporal.Now.instant(),
-		proofValue: new Uint8Array(sig)
+		created,
+		proofValue: sig
 	});
+	return {
+		proof,
+		securedDocument: capture ? await captureSecuredDocument(proof, compactMsg, msgCanon, proofCanon, new TextDecoder().decode(encodeMultibase("base58btc", sig)), contextLoader) : null
+	};
+}
+/**
+* Creates a proof for the given object.
+* @param object The object to create a proof for.
+* @param privateKey The private key to sign the proof with.
+* @param keyId The key ID to use in the proof. It will be used by the verifier.
+* @param options Additional options.  See also {@link CreateProofOptions}.
+* @returns The created proof.
+* @throws {TypeError} If the private key is invalid or unsupported.
+* @since 0.10.0
+*/
+async function createProof(object, privateKey, keyId, options = {}) {
+	const { proof } = await createProofInternal(object, privateKey, keyId, options);
+	return proof;
 }
 /**
 * Signs the given object with the private key and returns the signed object.
@@ -130,13 +181,19 @@ async function signObject(object, privateKey, keyId, options = {}) {
 			if (object.id != null) span.setAttribute("activitypub.object.id", object.id.href);
 			const existingProofs = [];
 			for await (const proof of object.getProofs(options)) existingProofs.push(proof);
-			const proof = await createProof(object, privateKey, keyId, options);
+			const { proof, securedDocument } = await createProofInternal(object, privateKey, keyId, options, existingProofs.length < 1);
 			if (span.isRecording()) {
 				if (proof.cryptosuite != null) span.setAttribute("object_integrity_proofs.cryptosuite", proof.cryptosuite);
 				if (proof.verificationMethodId != null) span.setAttribute("object_integrity_proofs.key_id", proof.verificationMethodId.href);
 				if (proof.proofValue != null) span.setAttribute("object_integrity_proofs.signature", encodeHex(proof.proofValue));
 			}
-			return object.clone({ proofs: [...existingProofs, proof] });
+			const signed = object.clone({ proofs: [...existingProofs, proof] });
+			if (securedDocument != null) retainSignedRepresentation(signed, securedDocument);
+			else if (existingProofs.length > 0) logger.debug("The object {objectId} already had {proofCount} proof(s), so its signed representation is not retained for embedding; the map-local compound-proof profile accepts exactly one direct proof per map.", {
+				objectId: object.id?.href,
+				proofCount: existingProofs.length
+			});
+			return signed;
 		} catch (error) {
 			span.setStatus({
 				code: SpanStatusCode.ERROR,

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

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

package/dist/secured-document-CxzZZ9nL.mjs

@@ -0,0 +1,35 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+//#region src/compat/secured-document.ts
+function isJsonMap(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+	return typeof value === "string" && value.length > 0;
+}
+function hasDataIntegrityProofType(value) {
+	return (Array.isArray(value) ? value : [value]).some((type) => type === "DataIntegrityProof" || type === "https://w3id.org/security#DataIntegrityProof");
+}
+/**
+* Checks whether a JSON value is a complete, self-contained secured document:
+* a map with its own `@context` and exactly one direct, map-valued `proof`
+* that carries every member `eddsa-jcs-2022` proof generation produces.
+*
+* This is deliberately stricter than {@link hasProofLike}, which exists to
+* decide whether a document is worth verifying.  Here a false positive would
+* silently suppress a wire-compatibility fix on an ordinary document, so a
+* partial or malformed proof does not qualify.
+*
+* @internal
+*/
+function isSelfContainedSecuredDocument(value) {
+	if (!isJsonMap(value)) return false;
+	if (!Object.hasOwn(value, "@context") || value["@context"] == null) return false;
+	if (!Object.hasOwn(value, "proof")) return false;
+	const proof = value.proof;
+	if (!isJsonMap(proof)) return false;
+	return hasDataIntegrityProofType(proof.type) && isNonEmptyString(proof.cryptosuite) && isNonEmptyString(proof.created) && isNonEmptyString(proof.verificationMethod) && isNonEmptyString(proof.proofPurpose) && isNonEmptyString(proof.proofValue);
+}
+//#endregion
+export { isSelfContainedSecuredDocument as t };

package/dist/{send-BzM5GLyn.mjs → send-n-W6bG7y.mjs}

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-CABhzCb_.mjs";
-import { n as getDurationMs, r as getFederationMetrics } from "./metrics-CISXCvB1.mjs";
-import { n as doubleKnock } from "./http-D9urSO2D.mjs";
+import { n as version, t as name } from "./deno-BcZNXlJn.mjs";
+import { n as getDurationMs, r as getFederationMetrics } from "./metrics-D7RydU_p.mjs";
+import { n as doubleKnock } from "./http-fIK5D83n.mjs";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { FetchError, UrlError, validatePublicUrl } from "@fedify/vocab-runtime";

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

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-CBlRfA-_.mjs";
-import "../std__assert-CxFT0MNt.mjs";
-import { n as inspectCompoundPortableObjectApplicability, t as discoverCompoundProofDocuments } from "../compound-proof-CJnWc6c-.mjs";
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { n as inspectCompoundPortableObjectApplicability, t as discoverCompoundProofDocuments } from "../compound-proof-CPvNisT2.mjs";
 import { t as map_local_create_note_default } from "../map-local-create-note-B0SeXJms.mjs";
 import { test } from "@fedify/fixture";
 //#region src/sig/compound-proof-discovery.test.ts

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-BDxNVZ3E.mjs";
-import { i as verifyCompoundProofDocuments, r as verifyCompoundPortableObjectProofs } from "../compound-proof-CJnWc6c-.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-4ADU3qy0.mjs";
+import { i as verifyCompoundProofDocuments, r as verifyCompoundPortableObjectProofs } from "../compound-proof-CPvNisT2.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-BDxNVZ3E.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-4ADU3qy0.mjs";
+import { i as verifyCompoundProofDocuments } from "../compound-proof-CPvNisT2.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-Ccs8cnd7.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-D9urSO2D.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-Xb1hVVZO.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-fIK5D83n.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-Ccs8cnd7.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-Xb1hVVZO.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";