@fedify/vocab 2.4.0-pr.936.41 → 2.4.0

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

@@ -0,0 +1,189 @@
+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-COZcxf00.mjs";
+import { mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, ok } from "node:assert/strict";
+import { isMarkerSafeContext, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";
+//#region src/signed-representation.test.ts
+const securedNote = {
+	"@context": [
+		"https://www.w3.org/ns/activitystreams",
+		"https://w3id.org/security/data-integrity/v1",
+		{ ex: "https://example.com/ns#" }
+	],
+	id: "https://example.com/notes/1",
+	type: "Note",
+	content: "Hello",
+	proof: {
+		"@context": [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{ ex: "https://example.com/ns#" }
+		],
+		type: "DataIntegrityProof",
+		cryptosuite: "eddsa-jcs-2022",
+		created: "2023-02-24T23:36:38Z",
+		verificationMethod: "https://example.com/person#ed25519-key",
+		proofPurpose: "assertionMethod",
+		proofValue: "z3FXQ"
+	}
+};
+const options = { contextLoader: mockDocumentLoader };
+function retainedNote() {
+	const note = new Note({
+		id: new URL("https://example.com/notes/1"),
+		content: "Hello"
+	});
+	retainSignedRepresentation(note, structuredClone(securedNote));
+	return note;
+}
+test("nested serialization embeds a retained signed representation", async () => {
+	deepStrictEqual((await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: retainedNote()
+	}).toJsonLd({
+		format: "compact",
+		...options
+	})).object, securedNote);
+});
+test("nested serialization embeds a retained representation through a compactable parent", async () => {
+	const wrapper = new Note({
+		id: new URL("https://example.com/notes/wrapper"),
+		attachments: [retainedNote()]
+	});
+	deepStrictEqual((await wrapper.toJsonLd(options)).attachment, securedNote);
+	const embeddedWrapper = (await new Question({
+		id: new URL("https://example.com/questions/1"),
+		exclusiveOptions: [wrapper]
+	}).toJsonLd(options)).oneOf;
+	deepStrictEqual(embeddedWrapper.attachment, securedNote);
+});
+test("nested serialization embeds one retained representation many times", async () => {
+	const note = retainedNote();
+	const compact = await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		objects: [note, note],
+		tags: [note]
+	}).toJsonLd({
+		format: "compact",
+		...options
+	});
+	const objects = compact.object;
+	deepStrictEqual(objects.length, 2);
+	deepStrictEqual(objects[0], securedNote);
+	deepStrictEqual(objects[1], securedNote);
+	deepStrictEqual(compact.tag, securedNote);
+	ok(objects[0] !== objects[1]);
+	ok(objects[0] !== compact.tag);
+});
+test("nested serialization embeds a retained representation at any depth", async () => {
+	const create = (await new Announce({
+		id: new URL("https://example.com/activities/2"),
+		actor: new URL("https://example.com/person"),
+		object: new Create({
+			id: new URL("https://example.com/activities/1"),
+			actor: new URL("https://example.com/person"),
+			object: retainedNote()
+		})
+	}).toJsonLd({
+		format: "compact",
+		...options
+	})).object;
+	deepStrictEqual(create.object, securedNote);
+});
+test("expanded serialization ignores a retained signed representation", async () => {
+	const objects = (await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: retainedNote()
+	}).toJsonLd({
+		format: "expand",
+		...options
+	}))[0]["https://www.w3.org/ns/activitystreams#object"];
+	deepStrictEqual(objects[0]["@id"], "https://example.com/notes/1");
+	deepStrictEqual(objects[0]["@type"], ["https://www.w3.org/ns/activitystreams#Note"]);
+});
+test("a context that could hide a placeholder turns retention off", async () => {
+	const embedded = (await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: retainedNote()
+	}).toJsonLd({
+		format: "compact",
+		context: [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{ identifier: "@id" }
+		],
+		...options
+	})).object;
+	deepStrictEqual(embedded["@context"], void 0);
+	deepStrictEqual(embedded.proof, void 0);
+});
+test("a clone does not inherit a retained signed representation", async () => {
+	const note = retainedNote();
+	const embedded = (await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: note.clone({ content: "Changed" })
+	}).toJsonLd({
+		format: "compact",
+		...options
+	})).object;
+	deepStrictEqual(embedded["@context"], void 0);
+	deepStrictEqual(embedded.content, "Changed");
+});
+test("every generated default context keeps placeholders recoverable", async () => {
+	const classes = Object.values(vocab_exports).filter((value) => typeof value === "function" && value.typeId instanceof URL);
+	ok(classes.length > 0);
+	for (const cls of classes) ok(isMarkerSafeContext((await new cls({ id: new URL("https://example.com/objects/1") }).toJsonLd())["@context"]), `${cls.typeId.href} has a default context that could hide a placeholder`);
+});
+test("a subtype that redefines an inherited property still embeds a retained representation", async () => {
+	const compact = await new OrderedCollection({
+		id: new URL("https://example.com/collections/1"),
+		items: [retainedNote()]
+	}).toJsonLd(options);
+	deepStrictEqual(compact.items, void 0);
+	deepStrictEqual(compact.orderedItems, [securedNote]);
+});
+test("a context that shadows the placeholder scheme turns retention off", async () => {
+	const embedded = (await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: retainedNote()
+	}).toJsonLd({
+		format: "compact",
+		context: [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{ urn: "https://example.com/ns#" }
+		],
+		...options
+	})).object;
+	deepStrictEqual(embedded["@context"], void 0);
+	deepStrictEqual(embedded.proof, void 0);
+});
+test("a context that aliases `@id` indirectly turns retention off", async () => {
+	const embedded = (await new Create({
+		id: new URL("https://example.com/activities/1"),
+		actor: new URL("https://example.com/person"),
+		object: retainedNote()
+	}).toJsonLd({
+		format: "compact",
+		context: [
+			"https://www.w3.org/ns/activitystreams",
+			"https://w3id.org/security/data-integrity/v1",
+			{
+				i: "id",
+				object: "as:object"
+			}
+		],
+		...options
+	})).object;
+	deepStrictEqual(embedded["@context"], void 0);
+	deepStrictEqual(embedded.proof, void 0);
+});
+//#endregion
+export {};

package/dist-tests/translation.test.mjs

@@ -0,0 +1,404 @@
+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-COZcxf00.mjs";
+import "./actor-D7_iX4I4.mjs";
+import "./lookup-IiNFWuXL.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";
+new URL("https://www.w3.org/ns/activitystreams#Public");
+//#endregion
+//#region src/translation.test.ts
+const { Temporal: TemporalPolyfill } = await import("temporal-polyfill");
+const AS = "https://www.w3.org/ns/activitystreams";
+const FEP = "https://w3id.org/fep/22cd";
+const SCHEMA = "https://schema.org/";
+const articleId = new URL("https://example.com/articles/1");
+const alice = new URL("https://example.com/users/alice");
+const context = [AS, FEP];
+const sourceUpdated = TemporalPolyfill.Instant.from("2026-09-01T00:00:00Z");
+const entry = {
+	type: "Translation",
+	inLanguage: "ko",
+	url: "https://example.com/articles/1/ko",
+	translator: [alice.href],
+	translationOfWork: articleId.href,
+	sourceUpdated: sourceUpdated.toString()
+};
+const example = {
+	"@context": context,
+	id: articleId.href,
+	type: "Article",
+	attributedTo: alice.href,
+	updated: sourceUpdated.toString(),
+	contentMap: {
+		en: "<p>Original text...</p>",
+		ko: "<p>번역 텍스트...</p>"
+	},
+	translations: [entry]
+};
+function translation() {
+	return new Translation({
+		language: new Intl.Locale("ko"),
+		translator: alice,
+		original: articleId,
+		sourceUpdated,
+		url: new URL(entry.url)
+	});
+}
+function article() {
+	return new Article({
+		id: articleId,
+		attribution: alice,
+		updated: sourceUpdated,
+		contents: [new LanguageString$1(example.contentMap.en, "en"), new LanguageString$1(example.contentMap.ko, "ko")],
+		translations: [translation()]
+	});
+}
+function record(value) {
+	ok(value != null && typeof value === "object" && !Array.isArray(value));
+	return value;
+}
+const noFetch = (url) => {
+	throw new Error(`Unexpected fetch: ${url}`);
+};
+function actorLoader(type, id) {
+	return (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: {
+			"@context": AS,
+			type,
+			id: id ?? url
+		}
+	});
+}
+test("FEP-22cd canonical context is preloaded", async () => {
+	ok(FEP in preloadedContexts);
+	deepStrictEqual(record((await getDocumentLoader()(FEP)).document)["@context"], {
+		"fep-22cd": `${FEP}#`,
+		schema: SCHEMA,
+		xsd: "http://www.w3.org/2001/XMLSchema#",
+		translations: {
+			"@id": "fep-22cd:translations",
+			"@container": "@set"
+		},
+		Translation: "fep-22cd:Translation",
+		sourceUpdated: {
+			"@id": "fep-22cd:sourceUpdated",
+			"@type": "xsd:dateTime"
+		},
+		translator: {
+			"@id": "schema:translator",
+			"@type": "@id",
+			"@container": "@set"
+		},
+		inLanguage: "schema:inLanguage",
+		translationOfWork: {
+			"@id": "schema:translationOfWork",
+			"@type": "@id"
+		},
+		isBasedOn: {
+			"@id": "schema:isBasedOn",
+			"@type": "@id"
+		}
+	});
+});
+test("FEP-22cd personal translation compact and expanded round trips", async () => {
+	for (const format of [
+		void 0,
+		"compact",
+		"expand"
+	]) {
+		const encoded = await article().toJsonLd({ format });
+		if (format !== "expand") {
+			deepStrictEqual(record(encoded).translations, [entry]);
+			ok(record(encoded)["@context"].includes(FEP));
+		}
+		const restored = await Article.fromJsonLd(encoded, { documentLoader: noFetch });
+		deepStrictEqual(restored.attributionId, alice);
+		deepStrictEqual(restored.contents, article().contents);
+		deepStrictEqual(restored.translations.length, 1);
+		const t = restored.translations[0];
+		deepStrictEqual(t.language?.baseName, "ko");
+		deepStrictEqual(t.original, articleId);
+		deepStrictEqual(t.translatorIds, [alice]);
+		deepStrictEqual(t.sourceUpdated?.toString(), sourceUpdated.toString());
+		deepStrictEqual(t.url, new URL(entry.url));
+		deepStrictEqual(record(await restored.toJsonLd({ format: "compact" })).translations, [entry]);
+	}
+	deepStrictEqual(record(await (await Article.fromJsonLd(example, { documentLoader: noFetch })).toJsonLd({
+		format: "compact",
+		context
+	})).translations, [entry]);
+	deepStrictEqual(await article().toJsonLd({
+		format: "compact",
+		context
+	}), example);
+});
+test("FEP-22cd full IRIs, optional revision, script language and AS links", async () => {
+	const expanded = {
+		"@type": `${FEP}#Translation`,
+		[`${SCHEMA}inLanguage`]: "zh-Hant",
+		[`${SCHEMA}translator`]: [{ "@id": alice.href }],
+		[`${SCHEMA}translationOfWork`]: { "@id": articleId.href },
+		[`${SCHEMA}isBasedOn`]: { "@id": `${articleId.href}/revisions/2` },
+		[`${AS}#url`]: [{ "@id": `${articleId.href}/zh-Hant` }, {
+			"@type": `${AS}#Link`,
+			[`${AS}#href`]: { "@id": `${articleId.href}/zh-Hant.html` }
+		}]
+	};
+	const t = await Translation.fromJsonLd(expanded, { documentLoader: noFetch });
+	deepStrictEqual(t.language?.baseName, "zh-Hant");
+	deepStrictEqual(t.original, articleId);
+	deepStrictEqual(t.basis?.href, `${articleId.href}/revisions/2`);
+	deepStrictEqual(t.sourceUpdated, null);
+	ok(t.urls[1] instanceof Link);
+	const compact = record(await t.toJsonLd({ format: "compact" }));
+	deepStrictEqual(compact.translator, [alice.href]);
+	deepStrictEqual(compact.inLanguage, "zh-Hant");
+	deepStrictEqual(compact.isBasedOn, `${articleId.href}/revisions/2`);
+	ok(!("sourceUpdated" in compact));
+	ok(Object.keys(compact).every((key) => !key.startsWith("https:")));
+});
+test("FEP-22cd organization languages, multiple translators and review-only Update", async () => {
+	const initial = article().clone({
+		attribution: new URL("https://example.com/orgs/acme"),
+		names: [new LanguageString$1("Title", "en"), new LanguageString$1("제목", "ko")],
+		summaries: [new LanguageString$1("Summary", "en"), new LanguageString$1("요약", "ko")],
+		contents: [
+			...article().contents,
+			new LanguageString$1("日本語版", "ja"),
+			"Fallback"
+		],
+		translations: [translation(), new Translation({
+			language: new Intl.Locale("ja"),
+			translators: [new URL("https://example.com/users/bob"), new URL("https://example.com/actors/translator")],
+			original: articleId
+		})]
+	});
+	const editedAt = TemporalPolyfill.Instant.from("2026-09-15T00:00:00Z");
+	const edited = initial.clone({ updated: editedAt });
+	ok(TemporalPolyfill.Instant.compare(edited.translations[0].sourceUpdated, edited.updated) < 0);
+	const reviewed = edited.clone({ translations: [edited.translations[0].clone({ sourceUpdated: edited.updated }), edited.translations[1]] });
+	const update = new Update({
+		id: new URL(`${articleId.href}/review`),
+		actor: alice,
+		object: reviewed
+	});
+	const object = await (await Update.fromJsonLd(await update.toJsonLd({ format: "compact" }), { documentLoader: noFetch })).getObject();
+	ok(object instanceof Article);
+	deepStrictEqual(object.id, articleId);
+	const byLanguage = (values) => Object.fromEntries(values.map((value) => [value instanceof LanguageString$1 ? value.locale.baseName : "@none", value.toString()]));
+	deepStrictEqual(byLanguage(object.contents), byLanguage(initial.contents));
+	deepStrictEqual(object.names, initial.names);
+	deepStrictEqual(object.summaries, initial.summaries);
+	deepStrictEqual(object.attributionId, initial.attributionId);
+	deepStrictEqual(object.translations.map((t) => t.language?.baseName), ["ko", "ja"]);
+	deepStrictEqual(object.translations[0].sourceUpdated?.toString(), editedAt.toString());
+	deepStrictEqual(object.translations[1].sourceUpdated, null);
+	deepStrictEqual(object.translations[1].translatorIds, initial.translations[1].translatorIds);
+	const withdrawn = reviewed.clone({
+		translations: [],
+		contents: [new LanguageString$1("Original", "en")]
+	});
+	const replaced = await Article.fromJsonLd(await withdrawn.toJsonLd());
+	deepStrictEqual(replaced.translations, []);
+	deepStrictEqual(replaced.id, articleId);
+});
+test("FEP-22cd nested fresh and cached objects compact without full-IRI terms", async () => {
+	for (const child of [article(), await Article.fromJsonLd(example)]) for (const wrapper of [new Create({ object: child }), new Collection({ items: [child] })]) for (const format of [void 0, "compact"]) {
+		const json = record(await wrapper.toJsonLd({ format }));
+		deepStrictEqual(record(json.object ?? json.items).translations, [entry]);
+		const roundTrip = await Object$1.fromJsonLd(json);
+		ok(roundTrip instanceof Create || roundTrip instanceof Collection);
+	}
+	const custom = record(await article().toJsonLd({
+		format: "compact",
+		context: AS
+	}));
+	deepStrictEqual(custom["@context"], AS);
+	ok(`${FEP}#translations` in custom);
+});
+test("FEP-22cd all actor types use the existing linked-object getters", async () => {
+	for (const Type of [
+		Person,
+		Organization,
+		Group,
+		Application,
+		Service
+	]) {
+		const t = new Translation({ translator: new Type({ id: alice }) });
+		ok(await t.getTranslator({ documentLoader: noFetch }) instanceof Type);
+		const parsed = await Translation.fromJsonLd(await t.toJsonLd());
+		ok(await parsed.getTranslator({ documentLoader: actorLoader(Type.name) }) instanceof Type);
+		deepStrictEqual((await Array.fromAsync(parsed.getTranslators())).length, 1);
+	}
+});
+test("FEP-22cd metadata ids are not fetched or trusted as actor origins", async () => {
+	for (const id of [void 0, "https://victim.example/metadata"]) for (const plural of [false, true]) {
+		const t = await Translation.fromJsonLd({
+			"@context": context,
+			type: "Translation",
+			...id == null ? {} : { id },
+			translator: [{
+				id: "https://victim.example/actor",
+				type: "Application"
+			}]
+		});
+		const fetched = [];
+		const documentLoader = (url) => {
+			fetched.push(url);
+			return actorLoader("Person")(url);
+		};
+		const actors = plural ? await Array.fromAsync(t.getTranslators({ documentLoader })) : [await t.getTranslator({ documentLoader })];
+		deepStrictEqual(fetched, ["https://victim.example/actor"]);
+		ok(actors[0] instanceof Person);
+		deepStrictEqual(t.id?.href, id);
+	}
+	const parsed = await Article.fromJsonLd({
+		...example,
+		translations: [{
+			...entry,
+			id: "urn:translation:ko"
+		}]
+	}, { documentLoader: noFetch });
+	deepStrictEqual(parsed.translations[0].id?.href, "urn:translation:ko");
+	await parsed.toJsonLd({ format: "compact" });
+});
+async function hasCompleteCredit(t, documentLoader) {
+	const ids = t.translatorIds;
+	const actors = await Array.fromAsync(t.getTranslators({
+		documentLoader,
+		suppressError: true
+	}));
+	return actors.length > 0 && actors.length >= ids.length && actors.every((actor) => actor.id != null);
+}
+test("FEP-22cd unavailable, deleted, mismatched and id-less actors leave status unknown", async () => {
+	for (const failedLoader of [
+		noFetch,
+		actorLoader("Tombstone"),
+		actorLoader("Person", "https://spoof.example/actor")
+	]) {
+		const t = new Translation({ translators: [alice, new Application({ id: new URL("https://example.com/machine") })] });
+		deepStrictEqual(await hasCompleteCredit(t, failedLoader), false);
+		deepStrictEqual(t.translatorIds, [alice, new URL("https://example.com/machine")]);
+		deepStrictEqual(record(await t.toJsonLd({ format: "compact" })).translator instanceof Array, true);
+	}
+	deepStrictEqual(await hasCompleteCredit(await Translation.fromJsonLd({
+		"@context": context,
+		type: "Translation",
+		translator: [alice.href, { type: "Application" }]
+	}), actorLoader("Person")), false);
+	await rejects(() => new Translation({ translator: alice }).getTranslator({ documentLoader: noFetch }), /Unexpected fetch/);
+	const t = new Translation({ translator: alice });
+	await rejects(() => t.getTranslator({
+		documentLoader: actorLoader("Person", "https://spoof.example/actor"),
+		crossOrigin: "throw"
+	}));
+});
+test("FEP-22cd malformed metadata follows vocabulary parsing behavior", async () => {
+	await rejects(() => Article.fromJsonLd({
+		...example,
+		translations: [{
+			...entry,
+			inLanguage: "not_a_language"
+		}]
+	}), RangeError);
+	await rejects(() => Article.fromJsonLd({
+		...example,
+		translations: [{
+			...entry,
+			sourceUpdated: "2026-09-01"
+		}]
+	}), RangeError);
+	await rejects(() => Article.fromJsonLd({
+		...example,
+		translations: [{
+			...entry,
+			type: "Note"
+		}]
+	}), TypeError);
+	const idOnly = await Article.fromJsonLd({
+		...example,
+		translations: [{ id: "urn:translation:ko" }]
+	}, { documentLoader: noFetch });
+	deepStrictEqual(idOnly.translations[0].id?.href, "urn:translation:ko");
+	deepStrictEqual(idOnly.translations[0].language, null);
+	deepStrictEqual(idOnly.translations[0].translatorIds, []);
+	deepStrictEqual((await Article.fromJsonLd({
+		...example,
+		translations: void 0
+	})).translations, []);
+});
+test("FEP-22cd ordinary multilingual serialization remains unchanged", async () => {
+	const fields = {
+		id: articleId,
+		attribution: alice,
+		contents: [
+			"Fallback",
+			new LanguageString$1("Original", "en"),
+			new LanguageString$1("번역", "ko")
+		],
+		names: [new LanguageString$1("Title", "en"), new LanguageString$1("제목", "ko")]
+	};
+	for (const Type of [
+		Article,
+		Note,
+		Object$1
+	]) for (const format of [void 0, "compact"]) {
+		const json = record(await new Type(fields).toJsonLd({ format }));
+		ok(!JSON.stringify(json["@context"]).includes(FEP));
+		deepStrictEqual(json.contentMap, {
+			en: "Original",
+			ko: "번역"
+		});
+		deepStrictEqual(json.content, "Fallback");
+		deepStrictEqual(json.nameMap, {
+			en: "Title",
+			ko: "제목"
+		});
+		deepStrictEqual(json.attributedTo, alice.href);
+		ok(!("translations" in json));
+	}
+});
+test("FEP-22cd keeps Mastodon PropertyValue and Schema.org translation namespaces distinct", async () => {
+	const json = record(await new Person({
+		id: alice,
+		attachments: [new PropertyValue({
+			name: "Website",
+			value: "https://example.com/"
+		})],
+		translations: [translation()]
+	}).toJsonLd());
+	deepStrictEqual(json.attachment, {
+		type: "PropertyValue",
+		name: "Website",
+		value: "https://example.com/"
+	});
+	deepStrictEqual(json.translations, [entry]);
+	const restored = await Person.fromJsonLd(json);
+	const attachments = await Array.fromAsync(restored.getAttachments());
+	ok(attachments[0] instanceof PropertyValue);
+	deepStrictEqual(attachments[0].value, "https://example.com/");
+	deepStrictEqual(restored.translations[0].original, articleId);
+});
+test("FEP-22cd explicit actor trust remains opt-in and clones retain untrusted state", async () => {
+	const parsed = await Translation.fromJsonLd({
+		"@context": context,
+		type: "Translation",
+		id: "https://victim.example/metadata",
+		translator: [{
+			id: "https://victim.example/actor",
+			type: "Application"
+		}]
+	});
+	ok(await parsed.getTranslator({
+		documentLoader: noFetch,
+		crossOrigin: "trust"
+	}) instanceof Application);
+	ok(await parsed.clone({ sourceUpdated }).getTranslator({ documentLoader: actorLoader("Person") }) instanceof Person);
+	ok(await parsed.clone({ translator: new Application({ id: alice }) }).getTranslator({ documentLoader: noFetch }) instanceof Application);
+});
+//#endregion
+export {};

package/dist-tests/translation.yaml

@@ -0,0 +1,91 @@
+$schema: ../../vocab-tools/schema.yaml
+name: Translation
+compactName: Translation
+uri: "https://w3id.org/fep/22cd#Translation"
+entity: false
+trustEmbeddedObjects: false
+description: |
+  Translator credit and source freshness for one language version of an
+  {@link Object}, as defined by the draft
+  [FEP-22cd](https://w3id.org/fep/22cd).  This is embedded metadata, not an
+  independent post or activity target.  Its optional identifier need not be
+  dereferenceable and does not establish trust in embedded translator actors.
+
+  Targets [draft revision 6d0d6559](https://codeberg.org/fediverse/fep/src/commit/6d0d6559054baeb7b71a5f2bdc14fc4c09b66f39/fep/22cd/fep-22cd.md).
+defaultContext:
+- "https://www.w3.org/ns/activitystreams"
+- "https://w3id.org/fep/22cd"
+properties:
+- singularName: language
+  functional: true
+  compactName: inLanguage
+  uri: "https://schema.org/inLanguage"
+  description: |
+    The translated language.  Publishers must match a language in the
+    containing object's content, name, or summary map.
+  range:
+  - "fedify:langTag"
+
+- pluralName: translators
+  singularName: translator
+  singularAccessor: true
+  compactName: translator
+  uri: "https://schema.org/translator"
+  extraContext: "https://w3id.org/fep/22cd"
+  description: |
+    The actors credited for this language version.  Their order has no
+    meaning.  Human actors credit translation or review; Application and
+    Service actors credit machine output.  If any actor cannot be resolved,
+    the entry's human-or-machine status is unknown.  Credit is asserted by
+    the publisher and grants no publishing authority.  Embedded actors with
+    identifiers are fetched before being returned unless explicitly trusted.
+  range:
+  - "https://www.w3.org/ns/activitystreams#Application"
+  - "https://www.w3.org/ns/activitystreams#Group"
+  - "https://www.w3.org/ns/activitystreams#Organization"
+  - "https://www.w3.org/ns/activitystreams#Person"
+  - "https://www.w3.org/ns/activitystreams#Service"
+
+- singularName: original
+  functional: true
+  compactName: translationOfWork
+  uri: "https://schema.org/translationOfWork"
+  description: |
+    The identifier of the containing object.  FEP-22cd translations share
+    that object's identity rather than introducing separate posts.
+  range:
+  - "http://www.w3.org/2001/XMLSchema#anyURI"
+
+- singularName: sourceUpdated
+  functional: true
+  compactName: sourceUpdated
+  uri: "https://w3id.org/fep/22cd#sourceUpdated"
+  description: |
+    The source object's updated timestamp (or published timestamp if it has
+    no updated timestamp) at the last human review of this translation.
+    An absent value makes no freshness claim.  A value earlier than the
+    current source timestamp indicates a potentially stale translation;
+    an equal or later value reflects the current source.
+  range:
+  - "http://www.w3.org/2001/XMLSchema#dateTime"
+
+- singularName: basis
+  functional: true
+  compactName: isBasedOn
+  uri: "https://schema.org/isBasedOn"
+  description: |
+    An optional public revision resource identifying the source reviewed.
+    Supplements sourceUpdated without requiring private revision history
+    to be exposed.
+  range:
+  - "http://www.w3.org/2001/XMLSchema#anyURI"
+
+- pluralName: urls
+  singularName: url
+  singularAccessor: true
+  compactName: url
+  uri: "https://www.w3.org/ns/activitystreams#url"
+  description: Links to renderings of this specific language version.
+  range:
+  - "http://www.w3.org/2001/XMLSchema#anyURI"
+  - "https://www.w3.org/ns/activitystreams#Link"

package/dist-tests/type.test.mjs

@@ -1,7 +1,7 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { H as getEntityTypeById, M as Person, U as isEntityType, w as Link } from "./vocab-Bjwctrxn.mjs";
-import { t as getTypeId } from "./type-_BlsfT3S.mjs";
+import { E as Link, F as Person, J as getEntityTypeById, Y as isEntityType } from "./vocab-COZcxf00.mjs";
+import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual } from "node:assert/strict";
 //#region src/type.test.ts