@fedify/vocab 2.4.0-dev.2122 → 2.4.0-dev.2127

package/dist-tests/{actor-CPhFJvyu.mjs → actor-Ccca2qzB.mjs}

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-BHtBRusa.mjs";
+import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-DFtGFGsb.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, isGatewayUrl } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
@@ -8,7 +8,7 @@ import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { domainToASCII, domainToUnicode } from "node:url";
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.4.0-dev.2122+bdc0ce8d";
+var version = "2.4.0-dev.2127+c41ce2eb";
 //#endregion
 //#region src/actor.ts
 const ACTOR_DISCOVERY_HISTOGRAM_BUCKETS = [

package/dist-tests/actor.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-BHtBRusa.mjs";
-import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-CPhFJvyu.mjs";
+import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-DFtGFGsb.mjs";
+import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-Ccca2qzB.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
 //#region ../../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js

package/dist-tests/{esm-C9nxP5_e.mjs → esm-CU6UbTlZ.mjs}

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { $ as __toESM, Z as __commonJSMin } from "./vocab-BHtBRusa.mjs";
+import { $ as __toESM, Z as __commonJSMin } from "./vocab-DFtGFGsb.mjs";
 //#endregion
 //#region ../../node_modules/.pnpm/regexparam@3.0.0/node_modules/regexparam/dist/index.mjs
 var import_glob_to_regexp = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {

package/dist-tests/gateway.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person, M as OrderedCollection, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-BHtBRusa.mjs";
-import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as traverseCollection } from "./lookup-Do6hKwnJ.mjs";
+import { F as Person, M as OrderedCollection, S as Image, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-DFtGFGsb.mjs";
+import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-CspwEMVG.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
@@ -1297,5 +1297,251 @@ test("singular accessors drop anonymous objects embedded in unsecured collection
 	deepStrictEqual(await outbox.getFirst(options), null);
 	deepStrictEqual(await Array.fromAsync(traverseCollection(outbox, options)), []);
 });
+function createCompatibleActivity(object, id = gatewayUrl("https://gw.example", "/activities/1"), options = {}) {
+	return Create.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Create",
+		id,
+		object
+	}, {
+		contextLoader: mockDocumentLoader,
+		...options
+	});
+}
+test("accessors of objects with compatible identifiers dereference references as portable objects", async (t) => {
+	await t.step("verifying the object at the reference", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: {
+			...note(),
+			id: compatibleNoteId
+		} });
+		const verifier = createRecordingVerifier();
+		const activity = await createCompatibleActivity(compatibleNoteId);
+		const object = await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.id, new URL(compatibleNoteId));
+		deepStrictEqual(documentLoader.fetched, [compatibleNoteId]);
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(verifier.calls[0].options.gatewayHints, [new URL("https://gw.example")]);
+		ok(verifier.calls[0].options.referrer?.object === activity);
+		deepStrictEqual(verifier.calls[0].options.referrer?.acceptance, void 0);
+	});
+	await t.step("rejecting an unsigned object at the reference", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: {
+			...note(),
+			id: compatibleNoteId
+		} });
+		deepStrictEqual(await (await createCompatibleActivity(compatibleNoteId)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false)
+		}), null);
+		deepStrictEqual(await Array.fromAsync((await createCompatibleActivity([compatibleNoteId])).getObjects({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false),
+			crossOrigin: "trust"
+		})), []);
+	});
+	await t.step("without verifyPortableObject", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: {
+			...note(),
+			id: compatibleNoteId
+		} });
+		const activity = await createCompatibleActivity(compatibleNoteId);
+		await rejects(async () => await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}), TypeError);
+		deepStrictEqual(await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			suppressError: true
+		}), null);
+		deepStrictEqual(documentLoader.fetched, []);
+	});
+	await t.step("embedded objects with compatible identifiers", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: note() });
+		const verifier = createRecordingVerifier();
+		const object = await (await createCompatibleActivity({
+			type: "Note",
+			id: compatibleNoteId,
+			content: "Embedded"
+		})).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.content, "Portable note");
+		deepStrictEqual(verifier.calls.length, 1);
+	});
+	await t.step("objects with malformed compatible identifiers", async () => {
+		const malformedId = `${gatewayUrl("https://gw.example", "/activities/1")}?@gateway=https%3A%2F%2Fgw2.example`;
+		const activity = await createCompatibleActivity(objectId, malformedId);
+		await rejects(async () => await activity.getObject({
+			documentLoader: createLoader({}),
+			contextLoader: mockDocumentLoader
+		}), TypeError);
+		const plainUrl = "https://example.com/notes/1";
+		const plainLoader = createLoader({ [plainUrl]: {
+			...note(),
+			id: plainUrl
+		} });
+		deepStrictEqual((await (await createCompatibleActivity(plainUrl, malformedId)).getObject({
+			documentLoader: plainLoader,
+			contextLoader: mockDocumentLoader
+		}))?.id, new URL(plainUrl));
+		const claimLoader = createLoader({ [plainUrl]: note() });
+		await rejects(async () => await (await createCompatibleActivity(plainUrl, malformedId)).getObject({
+			documentLoader: claimLoader,
+			contextLoader: mockDocumentLoader
+		}), TypeError);
+	});
+	await t.step("objects with ordinary HTTP(S) identifiers", async () => {
+		const documentLoader = createLoader({ [compatibleNoteId]: {
+			...note(),
+			id: compatibleNoteId
+		} });
+		deepStrictEqual((await (await createHttpActivity(compatibleNoteId)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}))?.id, new URL(compatibleNoteId));
+	});
+});
+test("objects use the verifyPortableObject option they were parsed with by default", async (t) => {
+	const attributedNote = (id) => ({
+		...note(id),
+		attributedTo: `ap://${did}/actor`
+	});
+	const actor = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		inbox: `ap://${did}/actor/inbox`
+	};
+	const documentLoader = createLoader({
+		[compatibleNoteId]: attributedNote(compatibleNoteId),
+		[gatewayUrl("https://gw.example", "/actor")]: actor
+	});
+	await t.step("fromJsonLd()", async () => {
+		const verifier = createRecordingVerifier();
+		const object = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: verifier })).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(verifier.calls.length, 1);
+		assertInstanceOf(await object.getAttribution({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"]
+		}), Person);
+		deepStrictEqual(verifier.calls.length, 2);
+		const embedded = await (await createCompatibleActivity(attributedNote(`ap://${did}/objects/2`), `ap://${did}/activities/1`, { verifyPortableObject: verifier })).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		});
+		assertInstanceOf(embedded, Note);
+		assertInstanceOf(await embedded.getAttribution({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"]
+		}), Person);
+		deepStrictEqual(verifier.calls.length, 3);
+	});
+	await t.step("the constructor and clone()", async () => {
+		const verifier = createRecordingVerifier();
+		const activity = new Create({
+			id: new URL(gatewayUrl("https://gw.example", "/activities/1")),
+			object: new URL(compatibleNoteId)
+		}, {
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(await activity.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}), Note);
+		deepStrictEqual(verifier.calls.length, 1);
+		const clone = activity.clone({ object: new URL(compatibleNoteId) });
+		await rejects(async () => await clone.getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}), TypeError);
+		assertInstanceOf(await activity.clone({ object: new URL(compatibleNoteId) }, {
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		}).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader
+		}), Note);
+		deepStrictEqual(verifier.calls.length, 2);
+	});
+	await t.step("an explicit option applies to that call only", async () => {
+		const stored = createRecordingVerifier();
+		const given = createRecordingVerifier();
+		const object = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored })).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: given
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual([stored.calls.length, given.calls.length], [0, 1]);
+		await object.getAttribution({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"]
+		});
+		deepStrictEqual([stored.calls.length, given.calls.length], [1, 1]);
+		const object2 = await (await createCompatibleActivity(compatibleNoteId)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: given
+		});
+		assertInstanceOf(object2, Note);
+		await rejects(async () => await object2.getAttribution({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"]
+		}), TypeError);
+	});
+	await t.step("lookupObject()", async () => {
+		const verifier = createRecordingVerifier();
+		const object = await lookupObject(compatibleNoteId, {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(verifier.calls.length, 1);
+		assertInstanceOf(await object.getAttribution({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			gateways: ["https://gw.example"]
+		}), Person);
+		deepStrictEqual(verifier.calls.length, 2);
+	});
+	await t.step("property preprocessors", async () => {
+		const verifier = createVerifier();
+		const icon = await (await Person.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: `ap://${did}/actor`,
+			type: "Person",
+			icon: {
+				type: "Link",
+				href: "https://example.com/icon.png"
+			}
+		}, {
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		})).getIcon({ documentLoader });
+		assertInstanceOf(icon, Image);
+		ok(icon._verifyPortableObject === verifier);
+	});
+});
 //#endregion
 export {};

package/dist-tests/{lookup-Do6hKwnJ.mjs → lookup-CspwEMVG.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1 } from "./vocab-BHtBRusa.mjs";
-import { i as isActor, o as name, s as version } from "./actor-CPhFJvyu.mjs";
+import { A as Object$1 } from "./vocab-DFtGFGsb.mjs";
+import { i as isActor, o as name, s as version } from "./actor-Ccca2qzB.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { canonicalizePortableUri, formatIri, getDocumentLoader, haveSameFe34Origin, haveSameIriOrigin, parseIri } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
@@ -279,6 +279,7 @@ async function lookupObjectInternal(identifier, options = {}) {
 				documentLoader,
 				contextLoader: snapshot?.loader ?? options.contextLoader,
 				tracerProvider: options.tracerProvider,
+				verifyPortableObject: options.verifyPortableObject,
 				baseUrl: documentUrl
 			});
 		} catch (error) {
@@ -419,6 +420,7 @@ async function dereference({ options, documentLoader }, id, gateways, extra = {}
 				documentLoader,
 				contextLoader,
 				tracerProvider,
+				verifyPortableObject: options.verifyPortableObject,
 				baseUrl
 			})
 		});

package/dist-tests/lookup.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-BHtBRusa.mjs";
-import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-Do6hKwnJ.mjs";
+import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-DFtGFGsb.mjs";
+import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-CspwEMVG.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, ok, rejects } from "node:assert/strict";

package/dist-tests/portable-lookup.test.mjs

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { F as Person } from "./vocab-BHtBRusa.mjs";
-import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as getActorHandle } from "./actor-CPhFJvyu.mjs";
-import { t as lookupObject } from "./lookup-Do6hKwnJ.mjs";
+import { F as Person } from "./vocab-DFtGFGsb.mjs";
+import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
+import { n as getActorHandle } from "./actor-Ccca2qzB.mjs";
+import { t as lookupObject } from "./lookup-CspwEMVG.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, rejects } from "node:assert/strict";

package/dist-tests/signed-representation.test.mjs

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { M as OrderedCollection, X as vocab_exports, i as Announce, k as Note, u as Create, z as Question } from "./vocab-BHtBRusa.mjs";
+import { M as OrderedCollection, X as vocab_exports, i as Announce, k as Note, u as Create, z as Question } from "./vocab-DFtGFGsb.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok } from "node:assert/strict";
 import { isMarkerSafeContext, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";

package/dist-tests/translation.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1, E as Link, F as Person, K as Translation, L as PropertyValue, P as Organization, U as Service, a as Application, b as Group, k as Note, o as Article, q as Update, s as Collection, u as Create } from "./vocab-BHtBRusa.mjs";
-import "./actor-CPhFJvyu.mjs";
-import "./lookup-Do6hKwnJ.mjs";
+import { A as Object$1, E as Link, F as Person, K as Translation, L as PropertyValue, P as Organization, U as Service, a as Application, b as Group, k as Note, o as Article, q as Update, s as Collection, u as Create } from "./vocab-DFtGFGsb.mjs";
+import "./actor-Ccca2qzB.mjs";
+import "./lookup-CspwEMVG.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
 import { LanguageString as LanguageString$1, getDocumentLoader, preloadedContexts } from "@fedify/vocab-runtime";

package/dist-tests/type.test.mjs

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { E as Link, F as Person, J as getEntityTypeById, Y as isEntityType } from "./vocab-BHtBRusa.mjs";
+import { E as Link, F as Person, J as getEntityTypeById, Y as isEntityType } from "./vocab-DFtGFGsb.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual } from "node:assert/strict";