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

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

@@ -0,0 +1,331 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
+import "../std__assert-DvMDRPes.mjs";
+import { a as inspectCompoundPortableObjectApplicability, n as discoverCompoundProofDocuments } from "../compound-proof-B-9mXxFW.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
+const limits = {
+	maxDepth: 16,
+	maxMaps: 32,
+	maxProofs: 8,
+	maxBytes: 16384
+};
+test("portable applicability is bounded and ignores metadata", () => {
+	assertEquals(inspectCompoundPortableObjectApplicability({
+		"@context": { id: "ap://did:key:context/object" },
+		proof: { id: "ap://did:key:proof/object" },
+		object: { id: "https://example.com/objects/1" }
+	}, limits), "absent");
+	assertEquals(inspectCompoundPortableObjectApplicability({ object: [{ "@id": "AP+EF61://did:key:child/objects/1" }] }, limits), "present");
+	assertEquals(inspectCompoundPortableObjectApplicability({ values: new Array(2e4).fill(0) }, {
+		...limits,
+		maxBytes: 1e3
+	}), "indeterminate");
+});
+test("discoverCompoundProofDocuments() returns immutable deepest-first candidates", () => {
+	const input = {
+		id: "ap://example.test/activities/1",
+		object: {
+			id: "ap://example.test/objects/1",
+			content: "one",
+			proof: {
+				type: "DataIntegrityProof",
+				proofValue: "zInner"
+			}
+		},
+		items: [{
+			id: "ap://example.test/objects/2",
+			content: "two",
+			proof: {
+				type: "DataIntegrityProof",
+				proofValue: "zArray"
+			}
+		}],
+		"a/b~c": {
+			"@id": "ap://example.test/objects/3",
+			proof: {
+				type: "DataIntegrityProof",
+				proofValue: "zEscaped"
+			}
+		},
+		proof: {
+			type: "DataIntegrityProof",
+			proofValue: "zOuter",
+			proof: {
+				type: "DataIntegrityProof",
+				proofValue: "zNotADocument"
+			}
+		}
+	};
+	const before = structuredClone(input);
+	const result = discoverCompoundProofDocuments(input, limits);
+	assertEquals(input, before);
+	assertEquals(result.status, "ok");
+	if (result.status !== "ok") return;
+	assertEquals(result.documents.map(({ path, id, depth }) => ({
+		path,
+		id,
+		depth
+	})), [
+		{
+			path: "/items/0",
+			id: "ap://example.test/objects/2",
+			depth: 2
+		},
+		{
+			path: "/a~1b~0c",
+			id: "ap://example.test/objects/3",
+			depth: 1
+		},
+		{
+			path: "/object",
+			id: "ap://example.test/objects/1",
+			depth: 1
+		},
+		{
+			path: "",
+			id: "ap://example.test/activities/1",
+			depth: 0
+		}
+	]);
+	assertEquals(result.documents[0].securedDocument, input.items[0]);
+	assertEquals(result.documents[0].proof, input.items[0].proof);
+	assertEquals(result.statistics.proofCount, 4);
+	input.items[0].content = "mutated after discovery";
+	assertEquals(result.documents[0].securedDocument.content, "two");
+	assertEquals(result.snapshot.items[0].content, "two");
+});
+test("discoverCompoundProofDocuments() is independent of member order", () => {
+	const first = {
+		z: {
+			id: "z",
+			proof: { proofValue: "z" }
+		},
+		a: {
+			id: "a",
+			proof: { proofValue: "a" }
+		},
+		proof: { proofValue: "root" }
+	};
+	const second = {
+		proof: { proofValue: "root" },
+		a: {
+			proof: { proofValue: "a" },
+			id: "a"
+		},
+		z: {
+			proof: { proofValue: "z" },
+			id: "z"
+		}
+	};
+	const firstResult = discoverCompoundProofDocuments(first, limits);
+	const secondResult = discoverCompoundProofDocuments(second, limits);
+	assertEquals(firstResult.status, "ok");
+	assertEquals(secondResult.status, "ok");
+	if (firstResult.status !== "ok" || secondResult.status !== "ok") return;
+	assertEquals(firstResult.documents.map((candidate) => candidate.path), [
+		"/a",
+		"/z",
+		""
+	]);
+	assertEquals(secondResult.documents.map((candidate) => candidate.path), [
+		"/a",
+		"/z",
+		""
+	]);
+});
+test("discoverCompoundProofDocuments() does not inspect context definitions", () => {
+	const result = discoverCompoundProofDocuments({
+		"@context": {
+			proof: "https://w3id.org/security#proof",
+			portable: {
+				"@id": "ap://did:key:z6MkContext/objects/1",
+				"@context": { proof: "https://example.com/nested-proof" }
+			}
+		},
+		id: "https://social.example/objects/1",
+		type: "Note"
+	}, limits);
+	assertEquals(result.status, "ok");
+	if (result.status !== "ok") return;
+	assertEquals(result.documents, []);
+	assertEquals(result.statistics.proofCount, 0);
+});
+test("discoverCompoundProofDocuments() preserves the recorded compound vector", () => {
+	const result = discoverCompoundProofDocuments(map_local_create_note_default.documents.finalSecuredCompound, limits);
+	assertEquals(result.status, "ok");
+	if (result.status !== "ok") return;
+	assertEquals(result.documents.map(({ path }) => path), ["/object", ""]);
+	assertEquals(result.documents[0].securedDocument, map_local_create_note_default.documents.securedInner);
+	assertEquals(result.documents[1].securedDocument, map_local_create_note_default.documents.finalSecuredCompound);
+});
+test("discoverCompoundProofDocuments() rejects unsupported proof shapes atomically", () => {
+	for (const proof of [
+		null,
+		"remote-proof",
+		[{ proofValue: "z" }]
+	]) assertEquals(discoverCompoundProofDocuments({
+		object: { proof: { proofValue: "valid candidate" } },
+		other: { proof }
+	}, limits), {
+		status: "unsupported",
+		reason: {
+			type: "unsupportedProofShape",
+			path: "/other/proof"
+		}
+	});
+});
+test("discoverCompoundProofDocuments() applies resource limits atomically", () => {
+	const cases = [
+		{
+			input: { child: { child: { proof: {} } } },
+			limits: {
+				...limits,
+				maxDepth: 1
+			},
+			limit: "depth",
+			maximum: 1
+		},
+		{
+			input: {
+				first: {},
+				second: { proof: {} }
+			},
+			limits: {
+				...limits,
+				maxMaps: 2
+			},
+			limit: "maps",
+			maximum: 2
+		},
+		{
+			input: {
+				first: { proof: {} },
+				second: { proof: {} }
+			},
+			limits: {
+				...limits,
+				maxProofs: 1
+			},
+			limit: "proofs",
+			maximum: 1
+		},
+		{
+			input: {
+				content: "too large",
+				proof: {}
+			},
+			limits: {
+				...limits,
+				maxBytes: 8
+			},
+			limit: "bytes",
+			maximum: 8
+		}
+	];
+	for (const fixture of cases) {
+		const result = discoverCompoundProofDocuments(fixture.input, fixture.limits);
+		assertEquals(result.status, "unsupported");
+		if (result.status !== "unsupported") continue;
+		assertEquals(result.reason.type, "limitExceeded");
+		if (result.reason.type !== "limitExceeded") continue;
+		assertEquals(result.reason.limit, fixture.limit);
+		assertEquals(result.reason.maximum, fixture.maximum);
+	}
+});
+test("discoverCompoundProofDocuments() rejects values that are not JSON trees", () => {
+	const cyclic = { proof: {} };
+	cyclic.self = cyclic;
+	const shared = { proof: {} };
+	const symbolKeyed = { [Symbol("hidden")]: { proof: {} } };
+	for (const input of [
+		[],
+		{ value: void 0 },
+		{ value: NaN },
+		cyclic,
+		{
+			first: shared,
+			second: shared
+		},
+		symbolKeyed
+	]) {
+		const result = discoverCompoundProofDocuments(input, limits);
+		assertEquals(result.status, "unsupported");
+		if (result.status !== "unsupported") continue;
+		assertEquals(result.reason.type, "invalidJsonTree");
+	}
+});
+test("discoverCompoundProofDocuments() handles wide JSON containers", () => {
+	const input = { values: new Array(2e5).fill(0) };
+	const result = discoverCompoundProofDocuments(input, {
+		maxDepth: 2,
+		maxMaps: 1,
+		maxProofs: 0,
+		maxBytes: 1048576
+	});
+	assertEquals(result.status, "ok");
+	if (result.status !== "ok") return;
+	assertEquals(result.statistics.byteLength, JSON.stringify(input).length);
+});
+test("discoverCompoundProofDocuments() rejects accessors without invoking them", () => {
+	let getterCalls = 0;
+	const accessorMap = {};
+	Object.defineProperty(accessorMap, "object", {
+		enumerable: true,
+		get() {
+			getterCalls++;
+			return { proof: {} };
+		}
+	});
+	const accessorArray = [{}];
+	Object.defineProperty(accessorArray, 0, {
+		enumerable: true,
+		get() {
+			getterCalls++;
+			return { proof: {} };
+		}
+	});
+	for (const input of [accessorMap, { items: accessorArray }]) {
+		const result = discoverCompoundProofDocuments(input, limits);
+		assertEquals(result.status, "unsupported");
+		if (result.status !== "unsupported") continue;
+		assertEquals(result.reason.type, "invalidJsonTree");
+	}
+	assertEquals(getterCalls, 0);
+});
+test("discoverCompoundProofDocuments() rejects non-enumerable map properties", () => {
+	const input = {};
+	Object.defineProperty(input, "proof", {
+		value: {},
+		enumerable: false
+	});
+	const result = discoverCompoundProofDocuments(input, limits);
+	assertEquals(result.status, "unsupported");
+	if (result.status !== "unsupported") return;
+	assertEquals(result.reason.type, "invalidJsonTree");
+});
+test("discoverCompoundProofDocuments() rejects non-JSON array properties", () => {
+	const namedProperty = Object.assign([], { extra: { proof: {} } });
+	const sparse = new Array(2);
+	sparse[1] = null;
+	const nonEnumerableIndex = [];
+	Object.defineProperty(nonEnumerableIndex, 0, {
+		value: { proof: {} },
+		enumerable: false
+	});
+	for (const input of [
+		{ items: namedProperty },
+		{ items: sparse },
+		{ items: nonEnumerableIndex }
+	]) {
+		const result = discoverCompoundProofDocuments(input, limits);
+		assertEquals(result.status, "unsupported");
+		if (result.status !== "unsupported") continue;
+		assertEquals(result.reason.type, "invalidJsonTree");
+	}
+});
+//#endregion
+export {};

package/dist/sig/compound-proof-producer.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

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 { a as inspectCompoundPortableObjectApplicability, i as findUnsupportedCompoundProofShape, t as containsCompoundPortableObject } from "../compound-proof-B-9mXxFW.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.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";