@fedify/vocab 2.4.0-pr.936.41 → 2.4.1

package/dist-tests/vocab.test.mjs

@@ -1,13 +1,15 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as OrderedCollectionPage, B as Source, C as InteractionRule, D as Note, E as Multikey, F as Question, I as QuoteAuthorization, L as QuoteRequest, M as Person, N as Place, O as Object$1, P as Proposal, R as Reject, S as InteractionPolicy, T as Measure, V as Tombstone, W as vocab_exports, _ as Follow, a as Application, b as Image, c as Create, d as Document, f as Endpoints, g as FeaturedItem, h as FeaturedCollection, i as Announce, j as Organization, k as Offer, l as CryptographicKey, m as FeatureRequest, n as Activity, o as Collection, p as FeatureAuthorization, r as Agreement, s as Commitment, t as Accept, u as Delete, v as Group, w as Link, x as Intent, y as Hashtag, z as Service } from "./vocab-Bjwctrxn.mjs";
-import { t as assertInstanceOf } from "./utils-CQjrpUkt.mjs";
+import { A as Object$1, B as QuoteAuthorization, C as Intent, D as Measure, E as Link, F as Person, G as Tombstone, H as Reject, I as Place, L as PropertyValue, N as OrderedCollectionPage, O as Multikey, P as Organization, R as Proposal, S as Image, T as InteractionRule, U as Service, V as QuoteRequest, W as Source, X as vocab_exports, _ as FeaturedCollection, a as Application, b as Group, d as CryptographicKey, f as Delete, g as FeatureRequest, h as FeatureAuthorization, i as Announce, j as Offer, k as Note, l as Commitment, m as Endpoints, n as Activity, p as Document, r as Agreement, s as Collection, t as Accept, u as Create, v as FeaturedItem, w as InteractionPolicy, x as Hashtag, y as Follow, z as Question } from "./vocab-DaniQwU7.mjs";
+import { t as esm_default } from "./esm-YWo4aQQe.mjs";
+import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
-import { deepStrictEqual, notDeepStrictEqual, ok, rejects, throws } from "node:assert/strict";
+import { deepStrictEqual, notDeepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
+import { FetchError, LanguageString, decodeMultibase, getDocumentLoader, parseDecimal, parseIri } from "@fedify/vocab-runtime";
 import { configure, reset } from "@logtape/logtape";
-import { LanguageString, decodeMultibase, parseDecimal } from "@fedify/vocab-runtime";
 import { pascalCase } from "es-toolkit";
 import { areAllScalarTypes, loadSchemaFiles } from "@fedify/vocab-tools";
+import { inspect } from "node:util";
 //#region src/vocab.test.ts
 const NOTE_QUOTE_CONTEXT = [
 	"https://www.w3.org/ns/activitystreams",
@@ -249,6 +251,91 @@ test("Object.toJsonLd()", async () => {
 		}
 	});
 });
+test("Note.fromJsonLd() ignores malformed language tags", async () => {
+	const note = await Note.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Note",
+		contentMap: {
+			invalid_tag: "Hello",
+			en: "Hi"
+		}
+	});
+	deepStrictEqual(note.contents, [new LanguageString("Hi", "en")]);
+	deepStrictEqual((await note.toJsonLd()).contentMap, { en: "Hi" });
+});
+test("Note.fromJsonLd() ignores malformed language tags in nested objects", async () => {
+	const note = await Note.fromJsonLd({
+		"@type": ["https://www.w3.org/ns/activitystreams#Note"],
+		"https://www.w3.org/ns/activitystreams#attachment": [{
+			"@type": ["http://schema.org#PropertyValue"],
+			"https://www.w3.org/ns/activitystreams#name": [{
+				"@value": "Malformed",
+				"@language": "invalid_tag"
+			}, {
+				"@value": "Valid",
+				"@language": "en"
+			}]
+		}]
+	});
+	deepStrictEqual(await Array.fromAsync(note.getAttachments()), [new PropertyValue({ name: new LanguageString("Valid", "en") })]);
+	const attachment = (await note.toJsonLd()).attachment;
+	deepStrictEqual(attachment.nameMap, { en: "Valid" });
+});
+test("Note.fromJsonLd() normalizes extlang language tags", async () => {
+	const json = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Note",
+		content: "<p>早晨</p>",
+		contentMap: {
+			"zh-YUE": "<p>早晨</p>",
+			"yue": "<p>早晨呀</p>"
+		}
+	};
+	const note = await Note.fromJsonLd(json);
+	deepStrictEqual(note.contents, [
+		"<p>早晨</p>",
+		new LanguageString("<p>早晨呀</p>", "yue"),
+		new LanguageString("<p>早晨</p>", "yue")
+	]);
+	deepStrictEqual(note.contents.map((c) => typeof c === "string" ? null : c.locale.baseName), [
+		null,
+		"yue",
+		"yue"
+	]);
+	deepStrictEqual(await note.toJsonLd(), json);
+	deepStrictEqual((await note.toJsonLd({ format: "compact" })).contentMap, { yue: ["<p>早晨呀</p>", "<p>早晨</p>"] });
+	deepStrictEqual((await note.toJsonLd({ format: "expand" }))[0]["https://www.w3.org/ns/activitystreams#content"], [
+		{ "@value": "<p>早晨</p>" },
+		{
+			"@value": "<p>早晨呀</p>",
+			"@language": "yue"
+		},
+		{
+			"@value": "<p>早晨</p>",
+			"@language": "yue"
+		}
+	]);
+	const expandedNote = await Note.fromJsonLd({
+		"@type": ["https://www.w3.org/ns/activitystreams#Note"],
+		"https://www.w3.org/ns/activitystreams#name": [{
+			"@value": "早晨",
+			"@language": "zh-yue-HK"
+		}]
+	});
+	deepStrictEqual(expandedNote.names, [new LanguageString("早晨", "yue-HK")]);
+	deepStrictEqual(expandedNote.names[0].locale.baseName, "yue-HK");
+});
+test("Note.fromJsonLd() caches original language tags", async () => {
+	const json = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Note",
+		contentMap: { "EN-us": "Hello" }
+	};
+	const note = await Note.fromJsonLd(json);
+	deepStrictEqual(note.contents, [new LanguageString("Hello", "en-US")]);
+	deepStrictEqual(note.contents[0].locale.baseName, "en-US");
+	deepStrictEqual(await note.toJsonLd(), json);
+});
 test("Note.toJsonLd()", async () => {
 	const note = new Note({ tags: [new Hashtag({
 		name: "#Fedify",
@@ -380,6 +467,22 @@ test("fromJsonLd() handles portable ActivityPub IRIs", async () => {
 	deepStrictEqual(pageJson.next, "ap+ef61://did:key:z6Mkabc/actor/outbox?page=2");
 	deepStrictEqual(pageJson.prev, "ap+ef61://did:key:z6Mkabc/actor/outbox?page=1");
 });
+test("fromJsonLd() refuses portable IDs changed by URL parsing", async () => {
+	const base = "ap://did:key:z6Mkabc";
+	for (const id of [
+		`${base}/a/../b`,
+		`${base}/a/%2e%2E/b`,
+		"https://gw.example/.well-known/apgateway/did:key:z6Mkabc/a/../b",
+		"https:/gw.example/.well-known/apgateway/did:key:z6Mkabc/a/../b"
+	]) await rejects(() => Note.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Note",
+		id
+	}, {
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	}), TypeError);
+});
 test("FEP-ef61: actor gateways round-trip as an ordered URI list", async () => {
 	const actorClasses = [
 		Application,
@@ -397,17 +500,112 @@ test("FEP-ef61: actor gateways round-trip as an ordered URI list", async () => {
 			gateways: gateways.map((gateway) => gateway.href)
 		});
 		deepStrictEqual(actor.gateways, gateways);
-		const jsonLd = await actor.toJsonLd();
+		const jsonLd = await actor.toJsonLd({ format: "compact" });
 		deepStrictEqual(jsonLd.type, ActorClass.name);
-		deepStrictEqual(jsonLd.gateways, gateways.map((gateway) => gateway.href));
+		deepStrictEqual(jsonLd.gateways, gateways.map((gateway) => gateway.origin));
 		deepStrictEqual((await ActorClass.fromJsonLd(jsonLd)).gateways, gateways);
 	}
 });
+test("FEP-ef61: actor gateways serialize as origins", async () => {
+	const actorClasses = [
+		Application,
+		Group,
+		Organization,
+		Person,
+		Service
+	];
+	const gateways = [
+		new URL("https://first.example:443/"),
+		new URL("http://second.example:80/"),
+		new URL("https://third.example:8443/"),
+		new URL("http://fourth.example:8080/")
+	];
+	const origins = [
+		"https://first.example",
+		"http://second.example",
+		"https://third.example:8443",
+		"http://fourth.example:8080"
+	];
+	for (const ActorClass of actorClasses) {
+		const actor = new ActorClass({
+			id: parseIri("ap://did:key:z6Mkabc/actor"),
+			gateways
+		});
+		const compact = await actor.toJsonLd();
+		deepStrictEqual(compact.gateways, origins);
+		const expanded = await actor.toJsonLd({ format: "expand" });
+		deepStrictEqual(expanded[0]["https://w3id.org/fep/ef61/gateways"], [{ "@list": origins.map((origin) => ({ "@id": origin })) }]);
+		deepStrictEqual(actor.gateways, gateways);
+		deepStrictEqual(actor.gateways.map((gateway) => gateway.href), origins.map((origin) => `${origin}/`));
+		deepStrictEqual((await ActorClass.fromJsonLd(compact)).gateways, gateways);
+		deepStrictEqual((await ActorClass.fromJsonLd(expanded)).gateways, gateways);
+	}
+});
+test("FEP-ef61: portable actors parse unmapped gateway lists", async () => {
+	const actorClasses = [
+		Application,
+		Group,
+		Organization,
+		Person,
+		Service
+	];
+	const gateways = ["https://first.example", "https://second.example"];
+	const ids = ["ap://did:key:z6Mkabc/actor", "https://first.example/.well-known/apgateway/did:key:z6Mkabc/actor"];
+	for (const ActorClass of actorClasses) for (const id of ids) deepStrictEqual((await ActorClass.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: ActorClass.name,
+		id,
+		inbox: `${id}/inbox`,
+		outbox: `${id}/outbox`,
+		gateways
+	})).gateways, gateways.map((g) => new URL(g)));
+});
+test("FEP-ef61: unmapped gateways retain their context meaning", async () => {
+	const actorClasses = [
+		Application,
+		Group,
+		Organization,
+		Person,
+		Service
+	];
+	const id = "ap://did:key:z6Mkabc/actor";
+	for (const ActorClass of actorClasses) {
+		const document = {
+			type: ActorClass.name,
+			id,
+			inbox: `${id}/inbox`,
+			outbox: `${id}/outbox`,
+			gateways: ["https://unmapped.example"]
+		};
+		for (const context of [
+			{ gateways: "https://example.com/unrelated" },
+			{ gateways: null },
+			{ "@vocab": "https://example.com/" },
+			{ [ActorClass.name]: {
+				"@id": `https://www.w3.org/ns/activitystreams#${ActorClass.name}`,
+				"@context": { gateways: "https://example.com/scoped" }
+			} }
+		]) deepStrictEqual((await ActorClass.fromJsonLd({
+			"@context": ["https://www.w3.org/ns/activitystreams", context],
+			...document
+		})).gateways, []);
+		deepStrictEqual((await ActorClass.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			...document,
+			id: "https://ordinary.example/actor"
+		})).gateways, []);
+		deepStrictEqual((await ActorClass.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			...document,
+			"https://w3id.org/fep/ef61/gateways": { "@list": [{ "@id": "https://canonical.example" }] }
+		})).gateways, [new URL("https://canonical.example")]);
+	}
+});
 test("FEP-ef61: actor gateways preserve single, empty, and invalid cases", async () => {
 	deepStrictEqual((await new Person({
 		id: new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"),
 		gateways: [new URL("https://server.example/")]
-	}).toJsonLd()).gateways, ["https://server.example/"]);
+	}).toJsonLd()).gateways, ["https://server.example"]);
 	ok(!("gateways" in await new Person({
 		id: new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"),
 		gateways: []
@@ -442,7 +640,9 @@ test("FEP-ef61: actor gateways must be HTTP(S) base URIs", async () => {
 		"https://user@server.example/",
 		"https://server.example/path",
 		"https://server.example/?x=1",
-		"https://server.example/#fragment"
+		"https://server.example/?",
+		"https://server.example/#fragment",
+		"https://server.example/#"
 	]) {
 		throws(() => new Person({
 			id: new URL("ap+ef61://did%3Akey%3Az6Mkabc/actor"),
@@ -1173,6 +1373,59 @@ test({
 		});
 	}
 });
+test({
+	name: "Announce.getObject() logs suppressed failures as warnings",
+	permissions: {
+		env: true,
+		read: true
+	},
+	async fn() {
+		const records = [];
+		const notFoundUrl = "https://example.com/suppressed-not-found";
+		const invalidObjectUrl = "https://example.com/invalid-object";
+		await reset();
+		esm_default.spyGlobal();
+		try {
+			await configure({
+				sinks: { buffer(record) {
+					records.push(record);
+				} },
+				filters: {},
+				loggers: [{
+					category: [],
+					sinks: ["buffer"]
+				}]
+			});
+			esm_default.get(notFoundUrl, { status: 404 });
+			deepStrictEqual(await new Announce({ object: new URL(notFoundUrl) }).getObject({ suppressError: true }), null);
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to fetch document: {status} {url} {headers}"));
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to fetch {url}: {error}"));
+			deepStrictEqual(records.some((record) => record.level === "error" && (record.rawMessage === "Failed to fetch document: {status} {url} {headers}" || record.rawMessage === "Failed to fetch {url}: {error}")), false);
+			records.length = 0;
+			const unsuppressedFetch = new Announce({ object: new URL(notFoundUrl) });
+			await rejects(() => unsuppressedFetch.getObject(), FetchError);
+			ok(records.some((record) => record.level === "error" && record.rawMessage === "Failed to fetch document: {status} {url} {headers}"));
+			records.length = 0;
+			const invalidDocumentLoader = async (url) => ({
+				contextUrl: null,
+				documentUrl: url,
+				document: null
+			});
+			deepStrictEqual(await new Announce({ object: new URL(invalidObjectUrl) }).getObject({
+				documentLoader: invalidDocumentLoader,
+				suppressError: true
+			}), null);
+			ok(records.some((record) => record.level === "warning" && record.rawMessage === "Failed to parse {url}: {error}"));
+			deepStrictEqual(records.some((record) => record.level === "error" && record.rawMessage === "Failed to parse {url}: {error}"), false);
+			records.length = 0;
+			const unsuppressedParsing = new Announce({ object: new URL(invalidObjectUrl) });
+			await rejects(() => unsuppressedParsing.getObject({ documentLoader: invalidDocumentLoader }), TypeError);
+		} finally {
+			esm_default.hardReset();
+			await reset();
+		}
+	}
+});
 test("Activity.getObject() fetches canonical portable IRIs", async () => {
 	const fetchedUrls = [];
 	const documentLoader = async (url) => {
@@ -1197,7 +1450,8 @@ test("Activity.getObject() fetches canonical portable IRIs", async () => {
 		contextLoader: mockDocumentLoader
 	})).getObject({
 		documentLoader,
-		contextLoader: mockDocumentLoader
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject: async () => ({ verified: true })
 	}), Note);
 	deepStrictEqual(fetchedUrls, ["ap+ef61://did:key:z6Mkabc/objects/1"]);
 });
@@ -1226,6 +1480,72 @@ test({
 		deepStrictEqual(objects2[0].name, "Second object");
 	}
 });
+function embeddedPropertyDocument(property) {
+	const context = "https://www.w3.org/ns/activitystreams";
+	return {
+		"@context": [context, { CustomImage: `${context}#Image` }],
+		type: property === "attachment" ? "Note" : "Create",
+		[property]: [
+			{
+				"@context": [context, { "@vocab": "https://example.com/" }],
+				type: "CustomImage",
+				name: "Malformed when reparsed"
+			},
+			{
+				"@context": context,
+				type: "Image",
+				name: "Cached image"
+			},
+			{
+				type: "Image",
+				name: "Decoded image"
+			}
+		]
+	};
+}
+for (const suppressError of [
+	void 0,
+	false,
+	true
+]) {
+	test(`Note.getAttachments() cached parse failure (suppressError: ${suppressError})`, async () => {
+		const jsonLd = embeddedPropertyDocument("attachment");
+		const note = await Note.fromJsonLd(jsonLd);
+		if (suppressError) {
+			for (let i = 0; i < 2; i++) deepStrictEqual((await Array.fromAsync(note.getAttachments({ suppressError }))).map((attachment) => attachment.name), ["Cached image", "Decoded image"]);
+			await rejects(() => Array.fromAsync(note.getAttachments()), TypeError);
+		} else await rejects(() => Array.fromAsync(note.getAttachments({ suppressError })), TypeError);
+		deepStrictEqual(await note.toJsonLd(), jsonLd);
+	});
+	test(`Activity.getObject() cached parse failure (suppressError: ${suppressError})`, async () => {
+		const jsonLd = embeddedPropertyDocument("object");
+		const activity = await Activity.fromJsonLd(jsonLd);
+		if (suppressError) {
+			deepStrictEqual(await activity.getObject({ suppressError }), null);
+			deepStrictEqual(await activity.getObject({ suppressError }), null);
+			await rejects(() => activity.getObject(), TypeError);
+		} else await rejects(() => activity.getObject({ suppressError }), TypeError);
+		deepStrictEqual(await activity.toJsonLd(), jsonLd);
+	});
+}
+test("Note.getAttachments() suppresses cached context loader failures", async () => {
+	const note = await Note.fromJsonLd(embeddedPropertyDocument("attachment"));
+	const contextLoader = () => Promise.reject(/* @__PURE__ */ new Error("Context loader failed"));
+	await rejects(() => Array.fromAsync(note.getAttachments({ contextLoader })), (error) => error instanceof Error && !(error instanceof TypeError));
+	deepStrictEqual((await Array.fromAsync(note.getAttachments({
+		contextLoader,
+		suppressError: true
+	}))).map((attachment) => attachment.name), ["Decoded image"]);
+});
+test("Activity.getObject() suppresses cached context loader failures", async () => {
+	const activity = await Activity.fromJsonLd(embeddedPropertyDocument("object"));
+	const contextLoader = () => Promise.reject(/* @__PURE__ */ new Error("Context loader failed"));
+	await rejects(() => activity.getObject({ contextLoader }), (error) => error instanceof Error && !(error instanceof TypeError));
+	deepStrictEqual(await activity.getObject({
+		contextLoader,
+		suppressError: true
+	}), null);
+});
 test("Activity.clone()", async () => {
 	const activity = new Activity({
 		actor: new Person({ name: "John Doe" }),
@@ -1273,6 +1593,21 @@ test({
 		}), "Deno" in globalThis ? "Object {\n  attribution: URL \"https://example.com/foo\",\n  contents: [\n    <en> \"Hello\",\n    <zh> \"你好\"\n  ],\n  id: URL \"https://example.com/\",\n  name: \"Test\"\n}" : "Object {\n  attribution: URL 'https://example.com/foo',\n  contents: [\n    <en> 'Hello',\n    <zh> '你好'\n  ],\n  id: URL 'https://example.com/',\n  name: 'Test'\n}");
 	}
 });
+test("inspecting an object prints portable IRIs in their canonical form", () => {
+	const did = "did:key:z6MkrJVnaZkeFzdQyMZu1cgjg7k1pZZ6pvBQ7XJPt4swbTQ2";
+	const obj = new Object$1({
+		id: parseIri(`ap://${did}/note`),
+		attribution: parseIri(`ap://${did}/actor`)
+	});
+	const inspected = [inspect(obj, { colors: false })];
+	if ("Deno" in globalThis) inspected.push(Deno.inspect(obj, { colors: false }));
+	for (const text of inspected) {
+		ok(text.includes(`ap+ef61://${did}/note`), text);
+		ok(text.includes(`ap+ef61://${did}/actor`), text);
+		ok(!text.includes("%3A"), text);
+	}
+	ok(inspect(new Object$1({ id: new URL("ap://not-a-did/note") })).includes("ap://not-a-did/note"));
+});
 test("Person.fromJsonLd()", async () => {
 	const person = await Person.fromJsonLd({
 		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
@@ -2103,6 +2438,83 @@ test("Delete.toJsonLd() compacts embedded QuoteRequest", async () => {
 		type: "Delete"
 	});
 });
+test("Note.quoteUrl (IRI-typed alias terms)", async () => {
+	const jsonLd = {
+		"@context": ["https://www.w3.org/ns/activitystreams", {
+			fedibird: "http://fedibird.com/ns#",
+			misskey: "https://misskey-hub.net/ns#",
+			_misskey_quote: {
+				"@id": "misskey:_misskey_quote",
+				"@type": "@id"
+			},
+			quoteUri: {
+				"@id": "fedibird:quoteUri",
+				"@type": "@id"
+			}
+		}],
+		id: "https://example.com/notes/1",
+		type: "Note",
+		_misskey_quote: "https://example.com/notes/quoted",
+		quoteUri: "https://example.com/notes/quoted2"
+	};
+	deepStrictEqual((await Note.fromJsonLd(jsonLd)).quoteUrl, new URL("https://example.com/notes/quoted"));
+	delete jsonLd._misskey_quote;
+	deepStrictEqual((await Note.fromJsonLd(jsonLd)).quoteUrl, new URL("https://example.com/notes/quoted2"));
+});
+test("Note.quoteUrl (IRI-typed primary term)", async () => {
+	const context = ["https://www.w3.org/ns/activitystreams", {
+		misskey: "https://misskey-hub.net/ns#",
+		quoteUrl: {
+			"@id": "as:quoteUrl",
+			"@type": "@id"
+		},
+		_misskey_quote: "misskey:_misskey_quote"
+	}];
+	deepStrictEqual((await Note.fromJsonLd({
+		"@context": context,
+		type: "Note",
+		quoteUrl: "https://example.com/object"
+	})).quoteUrl, new URL("https://example.com/object"));
+	deepStrictEqual((await Note.fromJsonLd({
+		"@context": context,
+		type: "Note",
+		quoteUrl: "https://example.com/object",
+		_misskey_quote: "https://example.com/object2"
+	})).quoteUrl, new URL("https://example.com/object"));
+});
+test("Note.quoteUrl (unparsable IRI-valued terms)", async () => {
+	const context = ["https://www.w3.org/ns/activitystreams", {
+		misskey: "https://misskey-hub.net/ns#",
+		_misskey_quote: {
+			"@id": "misskey:_misskey_quote",
+			"@type": "@id"
+		}
+	}];
+	for (const quote of [
+		{
+			type: "Note",
+			content: "An inlined quote without an id"
+		},
+		"_:b0",
+		"",
+		"notes/relative"
+	]) {
+		const loaded = await Note.fromJsonLd({
+			"@context": context,
+			id: "https://example.com/notes/1",
+			type: "Note",
+			content: "Hello",
+			_misskey_quote: quote
+		});
+		deepStrictEqual(loaded.quoteUrl, null, JSON.stringify(quote));
+		deepStrictEqual(loaded.content, "Hello");
+	}
+	deepStrictEqual((await Note.fromJsonLd({
+		"@context": context,
+		type: "Note",
+		_misskey_quote: "at://did:plc:abc/app.bsky.feed.post/xyz"
+	})).quoteUrl, new URL("at://" + encodeURIComponent("did:plc:abc/app.bsky.feed.post/xyz")));
+});
 test("Key.publicKey", async () => {
 	const jwk = {
 		kty: "RSA",
@@ -2200,6 +2612,22 @@ test("Link.fromJsonLd()", async () => {
 		"href": "at://did:plc:ia76kvnndjutgedggx2ibrem"
 	})).href, new URL("at://did%3Aplc%3Aia76kvnndjutgedggx2ibrem"));
 });
+test("Link.fromJsonLd() normalizes extlang hreflang", async () => {
+	const link = await Link.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Link",
+		href: "https://example.com/yue",
+		hreflang: "zh-YUE"
+	});
+	deepStrictEqual(link.language?.baseName, "yue");
+	deepStrictEqual((await link.toJsonLd({ format: "compact" })).hreflang, "yue");
+	await rejects(() => Link.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Link",
+		href: "https://example.com/en",
+		hreflang: "en-USA"
+	}), RangeError);
+});
 test("Person.fromJsonLd() with relative URLs", async () => {
 	deepStrictEqual((await (await Person.fromJsonLd({
 		"@context": ["https://www.w3.org/ns/activitystreams", "https://w3id.org/security/v1"],
@@ -2613,6 +3041,158 @@ test("FEP-fe34: Trust tracking in object cloning", () => {
 	});
 	deepStrictEqual(create.clone({ object: newNote }).objectId, new URL("https://example.com/new-note"));
 });
+for (const property of ["object", "attachment"]) for (const fetchOriginal of [false, true]) test(`clone() isolates ${property} dereferencing (${fetchOriginal ? "original" : "clone"} first)`, async () => {
+	const embedded = {
+		id: "https://b.example/notes/1",
+		type: "Note",
+		content: "embedded"
+	};
+	const json = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://a.example/activities/1",
+		type: "Create",
+		[property]: embedded
+	};
+	const original = await Create.fromJsonLd(json, { contextLoader: mockDocumentLoader });
+	const copy = original.clone();
+	const fetching = fetchOriginal ? original : copy;
+	const untouched = fetchOriginal ? copy : original;
+	let fetches = 0;
+	const documentLoader = async (url) => {
+		fetches++;
+		return {
+			contextUrl: null,
+			documentUrl: url,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				...embedded,
+				content: "fetched"
+			}
+		};
+	};
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	const fetched = property === "object" ? await fetching.getObject(options) : (await Array.fromAsync(fetching.getAttachments(options)))[0];
+	assertInstanceOf(fetched, Note);
+	deepStrictEqual(fetched.content, "fetched");
+	const trusted = { crossOrigin: "trust" };
+	const preserved = property === "object" ? await untouched.getObject(trusted) : (await Array.fromAsync(untouched.getAttachments(trusted)))[0];
+	assertInstanceOf(preserved, Note);
+	deepStrictEqual(preserved.content, "embedded");
+	deepStrictEqual((await original.toJsonLd())[property], fetchOriginal ? {
+		...embedded,
+		content: "fetched"
+	} : embedded);
+	const nested = (await new Accept({ object: untouched }).toJsonLd()).object;
+	deepStrictEqual(nested[property], embedded);
+	strictEqual(property === "object" ? await fetching.getObject(options) : (await Array.fromAsync(fetching.getAttachments(options)))[0], fetched);
+	deepStrictEqual(fetches, 1);
+	const independentlyFetched = property === "object" ? await untouched.getObject(options) : (await Array.fromAsync(untouched.getAttachments(options)))[0];
+	assertInstanceOf(independentlyFetched, Note);
+	deepStrictEqual(independentlyFetched.content, "fetched");
+	deepStrictEqual(fetches, 2);
+	const warmedClone = fetching.clone();
+	strictEqual(property === "object" ? await warmedClone.getObject(options) : (await Array.fromAsync(warmedClone.getAttachments(options)))[0], fetched);
+	deepStrictEqual(fetches, 2);
+});
+for (const clone of [false, true]) for (const frozen of [false, true]) test(`${clone ? "clone()" : "constructor"} copies ${frozen ? "frozen" : "mutable"} plural arrays`, async () => {
+	const items = [new URL("https://example.com/object"), new URL("https://example.com/object")];
+	const before = items.slice();
+	if (frozen) globalThis.Object.freeze(items);
+	const base = new Collection({});
+	const collection = clone ? base.clone({ items }) : new Collection({ items });
+	const sibling = clone ? base.clone({ items }) : new Collection({ items });
+	const fetched = await Array.fromAsync(collection.getItems({
+		documentLoader: mockDocumentLoader,
+		contextLoader: mockDocumentLoader
+	}));
+	deepStrictEqual(fetched.length, 2);
+	deepStrictEqual(fetched.map((item) => item.name), ["Fetched object", "Fetched object"]);
+	deepStrictEqual(items, before);
+	strictEqual(items[0], before[0]);
+	strictEqual(items[1], before[1]);
+	deepStrictEqual((await sibling.toJsonLd()).items, before.map(String));
+	if (!frozen) {
+		items.push(new URL("https://example.com/extra"));
+		deepStrictEqual(collection.itemIds, before);
+		deepStrictEqual(sibling.itemIds, before);
+	}
+});
+test("clone() copies scalar arrays without changing sparse inputs", () => {
+	const names = ["original"];
+	const original = new Object$1({ names });
+	names.push("caller mutation");
+	deepStrictEqual(original.names, ["original"]);
+	const copy = original.clone();
+	copy.names.push("clone mutation");
+	deepStrictEqual(original.names, ["original"]);
+	deepStrictEqual(copy.names, ["original", "clone mutation"]);
+	const replacements = ["replacement"];
+	const replaced = original.clone({ names: replacements });
+	replacements.push("caller mutation");
+	deepStrictEqual(replaced.names, ["replacement"]);
+	const sparseNames = new Array(2);
+	sparseNames[1] = "kept";
+	const sparse = new Object$1({ names: sparseNames });
+	for (const instance of [
+		sparse,
+		sparse.clone(),
+		sparse.clone({ names: sparse.names })
+	]) {
+		deepStrictEqual(instance.names.length, 2);
+		deepStrictEqual(0 in instance.names, false);
+		deepStrictEqual(instance.names[1], "kept");
+	}
+});
+test("clone() preserves embedded object identity and trust", async () => {
+	const note = new Note({ id: new URL("https://b.example/note") });
+	const original = new Create({
+		id: new URL("https://a.example/create"),
+		object: note
+	});
+	const documentLoader = async () => {
+		throw new Error("Trusted embedded objects must not be fetched.");
+	};
+	for (const instance of [
+		original,
+		original.clone(),
+		original.clone({ objects: [note] })
+	]) {
+		strictEqual(await instance.getObject({ documentLoader }), note);
+		strictEqual(instance.objectId, note.id);
+	}
+});
+test("clone() isolates crossOrigin trust when fetching", async () => {
+	const original = new Create({
+		id: new URL("https://a.example/create"),
+		object: new URL("https://b.example/note")
+	});
+	const copy = original.clone();
+	const documentLoader = async (url) => ({
+		contextUrl: null,
+		documentUrl: url,
+		document: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://other.example/note",
+			type: "Note",
+			content: "cross-origin"
+		}
+	});
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader
+	};
+	const trusted = await copy.getObject({
+		...options,
+		crossOrigin: "trust"
+	});
+	assertInstanceOf(trusted, Note);
+	deepStrictEqual(trusted.content, "cross-origin");
+	deepStrictEqual(await original.getObject(options), null);
+	deepStrictEqual(original.objectId, new URL("https://b.example/note"));
+});
 test("FEP-fe34: crossOrigin ignore behavior (default)", async () => {
 	const crossOriginDocumentLoader = async (url) => {
 		if (url === "https://different-origin.com/note") return {
@@ -2840,7 +3420,11 @@ test("FEP-fe34: Portable DID authorities are cross-origin boundaries", async ()
 		};
 		throw new Error("Document not found");
 	};
-	const result = await create.getObject({ documentLoader });
+	const result = await create.getObject({
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		verifyPortableObject: async () => ({ verified: true })
+	});
 	assertInstanceOf(result, Note);
 	deepStrictEqual(result.content, "Fetched portable note");
 });
@@ -3536,7 +4120,9 @@ for (const typeUri in types) {
 			...initValues
 		});
 		const jsonLd = await instance.toJsonLd({ contextLoader: mockDocumentLoader });
-		deepStrictEqual(jsonLd["@context"], type.defaultContext);
+		const defaultContexts = Array.isArray(type.defaultContext) ? type.defaultContext : [type.defaultContext];
+		const extraContexts = [...new Set(allProperties.flatMap((property) => property.extraContext == null || defaultContexts.some((context) => context === property.extraContext) ? [] : [property.extraContext]))];
+		deepStrictEqual(jsonLd["@context"], extraContexts.length === 0 ? type.defaultContext : [...defaultContexts, ...extraContexts]);
 		if (type.entity) deepStrictEqual(jsonLd.id, "https://example.com/");
 		const restored = await cls.fromJsonLd(jsonLd, {
 			documentLoader: mockDocumentLoader,
@@ -3599,5 +4185,309 @@ for (const typeUri in types) {
 		deepStrictEqual(cls.typeId, new URL(type.uri));
 	});
 }
+test("Announce.getObject() suppresses redirect, context, and private URL logs", async () => {
+	const records = [];
+	const objectUrl = "https://example.com/suppression-object";
+	const contextUrl = "https://example.com/suppression-context";
+	const scenarios = [
+		"redirect limit",
+		"redirect loop",
+		"context",
+		"private",
+		"private redirect"
+	];
+	await reset();
+	await configure({
+		sinks: { capture: (record) => {
+			records.push(record);
+		} },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const scenario of scenarios) {
+			esm_default.spyGlobal();
+			let fetches = 0;
+			esm_default.get("begin:https://example.com/", (call) => {
+				fetches++;
+				if (scenario === "redirect limit") return Response.redirect(`https://example.com/redirect-${fetches}`, 302);
+				if (scenario === "redirect loop") return Response.redirect(objectUrl, 302);
+				if (scenario === "private redirect") return Response.redirect("http://127.0.0.1/private", 302);
+				if (call.url === contextUrl) return new Response(null, { status: 404 });
+				return new Response(JSON.stringify({
+					"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+					id: objectUrl,
+					type: "Note"
+				}), { headers: { "Content-Type": "application/activity+json" } });
+			});
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					fetches = 0;
+					const announce = new Announce({ object: new URL(scenario === "private" ? "http://127.0.0.1/private" : objectUrl) });
+					if (suppressError) {
+						deepStrictEqual(await announce.getObject({ suppressError }), null);
+						deepStrictEqual(records.filter((r) => r.level === "error"), [], scenario);
+						ok(records.some((r) => r.level === "warning"), scenario);
+					} else {
+						await rejects(() => announce.getObject({ suppressError }));
+						ok(records.some((r) => r.level === "error"), scenario);
+					}
+					if (scenario === "private") deepStrictEqual(fetches, 0);
+					if (scenario === "private redirect") deepStrictEqual(fetches, 1);
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
+test("suppressed context loading does not persist on fetched objects", async () => {
+	const states = [];
+	const contextLoader = (url, options) => {
+		if (url === "https://www.w3.org/ns/activitystreams") return mockDocumentLoader(url);
+		states.push(options?.suppressError);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": {
+				as: "https://www.w3.org/ns/activitystreams#",
+				name: "as:name"
+			} }
+		});
+	};
+	const documentLoader = (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: {
+			"@context": ["https://www.w3.org/ns/activitystreams", "https://example.com/scoped-context"],
+			id: url,
+			type: url.endsWith("actor") ? "Person" : "Note",
+			attributedTo: "https://example.com/scoped-actor"
+		}
+	});
+	const note = await new Announce({ object: new URL("https://example.com/scoped-note") }).getObject({
+		documentLoader,
+		contextLoader,
+		suppressError: true
+	});
+	assertInstanceOf(note, Note);
+	ok(states.includes(true));
+	states.length = 0;
+	assertInstanceOf(await note.getAttribution(), Person);
+	ok(states.length > 0);
+	deepStrictEqual(states.includes(true), false);
+});
+test("attribution chains alternate ordinary and portable suppression", async () => {
+	const states = [];
+	const depths = [];
+	let hop = 0;
+	const contextUrl = "https://example.com/attribution-context";
+	const contextLoader = (url, options) => {
+		if (url !== contextUrl) return mockDocumentLoader(url, options);
+		states.push(options?.suppressError);
+		const stack = (/* @__PURE__ */ new Error()).stack;
+		ok(stack);
+		depths[hop]?.push(stack.split("\n").length);
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { "@context": { name: "https://www.w3.org/ns/activitystreams#name" } }
+		});
+	};
+	const documentLoader = (url) => {
+		const hop = Number(new URL(url).pathname.split("/").at(-1));
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: {
+				"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+				id: url,
+				type: "Person",
+				name: `Actor ${hop}`,
+				attributedTo: `https://example.com/actors/${hop + 1}`
+			}
+		});
+	};
+	let person = new Person({
+		id: new URL("https://example.com/actors/root"),
+		attribution: new URL("https://example.com/actors/0")
+	}, {
+		documentLoader,
+		contextLoader
+	});
+	const stackTraceLimit = globalThis.Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+	try {
+		ok(Reflect.set(Error, "stackTraceLimit", Infinity));
+		for (; hop < 100; hop++) {
+			depths[hop] = [];
+			const next = await person.getAttribution({
+				suppressError: true,
+				...hop % 2 === 0 ? {} : { verifyPortableObject: () => Promise.resolve({ verified: true }) }
+			});
+			assertInstanceOf(next, Person);
+			deepStrictEqual(next.id, new URL(`https://example.com/actors/${hop}`));
+			person = next;
+		}
+		ok(depths.every((values) => values.length > 0));
+		deepStrictEqual(depths[98], depths[2]);
+		deepStrictEqual(depths[99], depths[3]);
+		ok(states.length >= 100);
+		ok(states.every((state) => state === true));
+		states.length = 0;
+		assertInstanceOf(await person.getAttribution(), Person);
+		ok(states.length > 0);
+		ok(states.every((state) => state !== true));
+	} finally {
+		if (stackTraceLimit == null) Reflect.deleteProperty(Error, "stackTraceLimit");
+		else globalThis.Object.defineProperty(Error, "stackTraceLimit", stackTraceLimit);
+	}
+});
+test("portable accessors suppress document and context failure logs", async () => {
+	const records = [];
+	const id = new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/1");
+	const contextUrl = "https://example.com/portable-suppression-context";
+	await reset();
+	await configure({
+		sinks: { capture: (record) => {
+			records.push(record);
+		} },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const failContext of [false, true]) {
+			esm_default.spyGlobal();
+			esm_default.get("begin:https://example.com/", (call) => {
+				if (!failContext || call.url === contextUrl) return new Response(null, { status: 404 });
+				return new Response(JSON.stringify({
+					"@context": ["https://www.w3.org/ns/activitystreams", contextUrl],
+					id: "ap://did:key:z6Mkabc/objects/1",
+					type: "Note"
+				}), { headers: { "Content-Type": "application/activity+json" } });
+			});
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					const announce = new Announce({ object: id });
+					const options = {
+						suppressError,
+						gateways: ["https://example.com/"],
+						verifyPortableObject: () => Promise.resolve({ verified: true })
+					};
+					if (suppressError) {
+						deepStrictEqual(await announce.getObject(options), null);
+						deepStrictEqual(records.filter((r) => r.level === "error"), []);
+						ok(records.some((r) => r.level === "warning"));
+					} else {
+						await rejects(() => announce.getObject(options));
+						ok(records.some((r) => r.level === "error"));
+					}
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
+test("portable verifiers suppress document logs only during dereferencing", async () => {
+	const records = [];
+	const id = new URL("ap+ef61://did%3Akey%3Az6Mkabc/objects/1");
+	const verificationUrl = "https://example.com/verification-document";
+	const missingUrl = "https://example.com/missing-verification-document";
+	const signal = new AbortController().signal;
+	await reset();
+	await configure({
+		sinks: { capture: (record) => records.push(record) },
+		loggers: [{
+			category: ["fedify"],
+			lowestLevel: "debug",
+			sinks: ["capture"]
+		}]
+	});
+	try {
+		for (const failVerification of [false, true]) {
+			esm_default.spyGlobal();
+			esm_default.get("begin:https://example.com/.well-known/", {
+				headers: { "Content-Type": "application/activity+json" },
+				body: {
+					"@context": "https://www.w3.org/ns/activitystreams",
+					id: "ap://did:key:z6Mkabc/objects/1",
+					type: "Note"
+				}
+			});
+			esm_default.get(verificationUrl, {
+				status: failVerification ? 404 : 200,
+				headers: { "Content-Type": "application/ld+json" },
+				body: {}
+			});
+			esm_default.get(missingUrl, { status: 404 });
+			try {
+				for (const suppressError of [
+					true,
+					false,
+					void 0
+				]) {
+					records.length = 0;
+					const baseLoader = getDocumentLoader();
+					const calls = [];
+					const documentLoader = (url, options) => {
+						calls.push(options);
+						return baseLoader(url, options);
+					};
+					let retainedLoader;
+					const loaderOptions = { signal };
+					const object = await new Announce({ object: id }).getObject({
+						suppressError,
+						documentLoader,
+						gateways: ["https://example.com/"],
+						verifyPortableObject: async (_document, options) => {
+							retainedLoader = options.documentLoader;
+							ok(options.documentLoader);
+							await options.documentLoader(verificationUrl, loaderOptions);
+							return { verified: true };
+						}
+					});
+					if (failVerification) {
+						deepStrictEqual(object, null);
+						deepStrictEqual(records.some((record) => record.level === "error"), !suppressError);
+						ok(records.some((record) => record.level === "warning"));
+					} else assertInstanceOf(object, Note);
+					deepStrictEqual(calls.at(-1)?.signal, signal);
+					deepStrictEqual(calls.at(-1)?.suppressError, suppressError ? true : void 0);
+					deepStrictEqual(loaderOptions, { signal });
+					records.length = 0;
+					const releasedLoader = retainedLoader;
+					ok(releasedLoader);
+					await rejects(() => releasedLoader(missingUrl, loaderOptions), FetchError);
+					deepStrictEqual(calls.at(-1), loaderOptions);
+					ok(records.some((record) => record.level === "error"));
+				}
+			} finally {
+				esm_default.hardReset();
+			}
+		}
+	} finally {
+		await reset();
+	}
+});
 //#endregion
 export {};