@fedify/vocab 2.5.0-dev.2332 → 2.5.0-dev.2355

package/dist-tests/{actor-DpNkhFU9.mjs → actor-BbIjMjNa.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-EFWWufqL.mjs";
+import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-Cg2PG-xH.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.5.0-dev.2332+d4e3f91f";
+var version = "2.5.0-dev.2355+c92a1cb1";
 //#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-EFWWufqL.mjs";
-import { t as esm_default } from "./esm-Cncdk-Cm.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-DpNkhFU9.mjs";
+import { $ as __exportAll, F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-Cg2PG-xH.mjs";
+import { t as esm_default } from "./esm-rg6f9oLR.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-BbIjMjNa.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/application.yaml

@@ -351,3 +351,18 @@ properties:
     attached in some clients.
   range:
   - "http://www.w3.org/2001/XMLSchema#boolean"
+
+- singularName: preferredLicense
+  functional: true
+  compactName: preferredLicense
+  uri: "https://w3id.org/fep/6757#preferredLicense"
+  extraContext: "https://w3id.org/fep/6757"
+  description: |
+    The URI of the license this actor prefers for the new objects it creates,
+    as defined by [FEP-6757](https://w3id.org/fep/6757).  A client can use it
+    as the default `license` of a new object and let the user choose another.
+
+    This is not a fallback license: an object without its own `license` is not
+    licensed under its author's preferred license.
+  range:
+  - "fedify:absoluteIri"

package/dist-tests/{esm-Cncdk-Cm.mjs → esm-rg6f9oLR.mjs}

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { $ as __toESM, Z as __commonJSMin } from "./vocab-EFWWufqL.mjs";
+import { Q as __commonJSMin, et as __toESM } from "./vocab-Cg2PG-xH.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, S as Image, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-EFWWufqL.mjs";
-import { t as esm_default } from "./esm-Cncdk-Cm.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-CIDHxy5l.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-Cg2PG-xH.mjs";
+import { t as esm_default } from "./esm-rg6f9oLR.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-DKLMyPMJ.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";

package/dist-tests/group.yaml

@@ -351,3 +351,18 @@ properties:
     attached in some clients.
   range:
   - "http://www.w3.org/2001/XMLSchema#boolean"
+
+- singularName: preferredLicense
+  functional: true
+  compactName: preferredLicense
+  uri: "https://w3id.org/fep/6757#preferredLicense"
+  extraContext: "https://w3id.org/fep/6757"
+  description: |
+    The URI of the license this actor prefers for the new objects it creates,
+    as defined by [FEP-6757](https://w3id.org/fep/6757).  A client can use it
+    as the default `license` of a new object and let the user choose another.
+
+    This is not a fallback license: an object without its own `license` is not
+    licensed under its author's preferred license.
+  range:
+  - "fedify:absoluteIri"

package/dist-tests/license.test.mjs

@@ -0,0 +1,538 @@
+import "temporal-polyfill";
+globalThis.addEventListener = () => {};
+import { E as Link, F as Person, J as Video, P as Organization, S as Image, U as Service, a as Application, b as Group, k as Note, s as Collection, u as Create, z as Question } from "./vocab-Cg2PG-xH.mjs";
+import "./src-DVk5F9Ik.mjs";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok } from "node:assert/strict";
+import { getDocumentLoader, preloadedContexts } from "@fedify/vocab-runtime";
+import jsonld from "@fedify/vocab-runtime/jsonld";
+//#region src/license.test.ts
+const AS = "https://www.w3.org/ns/activitystreams";
+const FEP = "https://w3id.org/fep/6757";
+const DC_LICENSE = "http://purl.org/dc/terms/license";
+const PREFERRED_LICENSE = `${FEP}#preferredLicense`;
+const SCHEMA_LICENSE = "https://schema.org/license";
+const HTTP_SCHEMA_LICENSE = "http://schema.org/license";
+const CC_LICENSE = "http://creativecommons.org/ns#license";
+const BY = "https://creativecommons.org/licenses/by/4.0/";
+const BY_NC = "https://creativecommons.org/licenses/by-nc/4.0/";
+const BY_NC_ND = "https://creativecommons.org/licenses/by-nc-nd/4.0/";
+const CC0 = "https://creativecommons.org/publicdomain/zero/1.0/";
+const PD_MARK = "https://creativecommons.org/publicdomain/mark/1.0/";
+const noteExample = {
+	"@context": [
+		AS,
+		FEP,
+		{ schema: "https://schema.org/" }
+	],
+	id: "https://social.example/note/857",
+	type: "Note",
+	content: "Hello, world!",
+	license: BY,
+	"schema:license": BY,
+	attachment: {
+		type: "Link",
+		href: "https://media.social.example/uploads/file339.jpg",
+		mediaType: "image/jpeg",
+		license: PD_MARK
+	}
+};
+const personExample = {
+	"@context": [AS, FEP],
+	id: "https://social.example/user/1753",
+	type: "Person",
+	name: "Example User",
+	inbox: "https://social.example/collection/9257",
+	outbox: "https://social.example/collection/10772",
+	summary: "An example user who is very illustrative of important features",
+	license: BY_NC_ND,
+	icon: {
+		type: "Image",
+		license: BY_NC,
+		url: {
+			type: "Link",
+			mediaType: "image/jpeg",
+			href: "https://media.social.example/upload/7272.jpg"
+		}
+	},
+	preferredLicense: BY_NC
+};
+function record(value) {
+	ok(value != null && typeof value === "object" && !Array.isArray(value));
+	return value;
+}
+const noFetch = (url) => {
+	throw new Error(`Unexpected fetch: ${url}`);
+};
+/**
+* A context loader that serves only preloaded contexts and records them.
+*/
+function offlineContextLoader() {
+	const loaded = [];
+	const loader = getDocumentLoader();
+	const contextLoader = (url, options) => {
+		if (!(url in preloadedContexts)) throw new Error(`Unexpected context fetch: ${url}`);
+		loaded.push(url);
+		return loader(url, options);
+	};
+	return Object.assign(contextLoader, { loaded });
+}
+async function expand(json) {
+	return record((await jsonld.expand(json, { documentLoader: getDocumentLoader() }))[0]);
+}
+function contexts(json) {
+	const context = record(json)["@context"];
+	return Array.isArray(context) ? context : [context];
+}
+function note(licenses = [new URL(BY)]) {
+	return new Note({
+		id: new URL("https://social.example/note/857"),
+		content: "Hello, world!",
+		licenses
+	});
+}
+test("FEP-6757 context is preloaded", async () => {
+	ok(FEP in preloadedContexts);
+	deepStrictEqual(record((await getDocumentLoader()(FEP)).document)["@context"], {
+		license: {
+			"@id": DC_LICENSE,
+			"@type": "@id"
+		},
+		preferredLicense: {
+			"@id": PREFERRED_LICENSE,
+			"@type": "@id"
+		}
+	});
+});
+test("FEP-6757 note example is parsed offline", async () => {
+	const contextLoader = offlineContextLoader();
+	const parsed = await Note.fromJsonLd(noteExample, {
+		documentLoader: noFetch,
+		contextLoader
+	});
+	deepStrictEqual(parsed.licenses, [new URL(BY)]);
+	const attachments = await Array.fromAsync(parsed.getAttachments({
+		documentLoader: noFetch,
+		contextLoader
+	}));
+	deepStrictEqual(attachments.length, 1);
+	ok(attachments[0] instanceof Link);
+	deepStrictEqual(attachments[0].licenses, [new URL(PD_MARK)]);
+	ok(contextLoader.loaded.includes(FEP));
+	deepStrictEqual(await parsed.toJsonLd(), noteExample);
+});
+test("FEP-6757 person example is parsed offline", async () => {
+	const contextLoader = offlineContextLoader();
+	const person = await Person.fromJsonLd(personExample, {
+		documentLoader: noFetch,
+		contextLoader
+	});
+	deepStrictEqual(person.licenses, [new URL(BY_NC_ND)]);
+	deepStrictEqual(person.preferredLicense, new URL(BY_NC));
+	const icon = await person.getIcon({
+		documentLoader: noFetch,
+		contextLoader
+	});
+	ok(icon instanceof Image);
+	deepStrictEqual(icon.licenses, [new URL(BY_NC)]);
+	const url = icon.url;
+	ok(url instanceof Link);
+	deepStrictEqual(url.licenses, []);
+	deepStrictEqual(await person.toJsonLd(), personExample);
+});
+test("FEP-6757 license is written only as the canonical IRI", async () => {
+	for (const format of [void 0, "compact"]) {
+		const json = record(await note().toJsonLd({ format }));
+		deepStrictEqual(contexts(json).at(-1), FEP);
+		deepStrictEqual(json.license, BY);
+		const expanded = await expand(json);
+		deepStrictEqual(expanded[DC_LICENSE], [{ "@id": BY }]);
+		for (const synonym of [
+			SCHEMA_LICENSE,
+			HTTP_SCHEMA_LICENSE,
+			CC_LICENSE
+		]) ok(!(synonym in expanded));
+	}
+	deepStrictEqual(record((await note().toJsonLd({ format: "expand" }))[0])[DC_LICENSE], [{ "@id": BY }]);
+});
+test("FEP-6757 multiple licenses are alternatives in observed order", async () => {
+	const licenses = [new URL(BY), new URL(CC0)];
+	const json = record(await note(licenses).toJsonLd());
+	deepStrictEqual(json.license, [BY, CC0]);
+	deepStrictEqual((await Note.fromJsonLd(json, { documentLoader: noFetch })).licenses, licenses);
+});
+test("FEP-6757 objects without license metadata serialize as before", async () => {
+	const fields = {
+		id: new URL("https://social.example/note/1"),
+		content: "No license"
+	};
+	for (const format of [void 0, "compact"]) {
+		const json = record(await new Note(fields).toJsonLd({ format }));
+		ok(!JSON.stringify(json["@context"]).includes(FEP));
+		ok(!("license" in json));
+		const person = record(await new Person({ id: new URL("https://social.example/user/1") }).toJsonLd({ format }));
+		ok(!JSON.stringify(person["@context"]).includes(FEP));
+		ok(!("preferredLicense" in person));
+	}
+	deepStrictEqual(await new Note(fields).toJsonLd(), {
+		"@context": [
+			AS,
+			"https://w3id.org/security/data-integrity/v1",
+			"https://gotosocial.org/ns",
+			{
+				toot: "http://joinmastodon.org/ns#",
+				misskey: "https://misskey-hub.net/ns#",
+				fedibird: "http://fedibird.com/ns#",
+				sensitive: "as:sensitive",
+				Emoji: "toot:Emoji",
+				Hashtag: "as:Hashtag",
+				quote: {
+					"@id": "https://w3id.org/fep/044f#quote",
+					"@type": "@id"
+				},
+				quoteUrl: "as:quoteUrl",
+				_misskey_quote: "misskey:_misskey_quote",
+				quoteUri: "fedibird:quoteUri",
+				QuoteAuthorization: "https://w3id.org/fep/044f#QuoteAuthorization",
+				quoteAuthorization: {
+					"@id": "https://w3id.org/fep/044f#quoteAuthorization",
+					"@type": "@id"
+				},
+				emojiReactions: {
+					"@id": "fedibird:emojiReactions",
+					"@type": "@id"
+				}
+			}
+		],
+		id: "https://social.example/note/1",
+		type: "Note",
+		content: "No license"
+	});
+});
+test("FEP-6757 preferredLicense on every actor type", async () => {
+	for (const Actor of [
+		Application,
+		Group,
+		Organization,
+		Person,
+		Service
+	]) {
+		const actor = new Actor({
+			id: new URL("https://social.example/actor"),
+			preferredLicense: new URL(BY_NC)
+		});
+		for (const format of [void 0, "compact"]) {
+			const json = record(await actor.toJsonLd({ format }));
+			deepStrictEqual(contexts(json).at(-1), FEP);
+			deepStrictEqual(json.preferredLicense, BY_NC);
+			ok(!("license" in json));
+			deepStrictEqual((await expand(json))[PREFERRED_LICENSE], [{ "@id": BY_NC }]);
+			const parsed = await Actor.fromJsonLd(json, { documentLoader: noFetch });
+			deepStrictEqual(parsed.preferredLicense, new URL(BY_NC));
+			deepStrictEqual(parsed.licenses, []);
+		}
+	}
+});
+test("FEP-6757 licenses in activities compact to the license term", async () => {
+	const create = new Create({
+		id: new URL("https://social.example/create/1"),
+		actor: new URL("https://social.example/user/1753"),
+		object: note()
+	});
+	for (const format of [void 0, "compact"]) {
+		const json = record(await create.toJsonLd({ format }));
+		deepStrictEqual(contexts(json).at(-1), FEP);
+		deepStrictEqual(record(json.object).license, BY);
+		ok(!("license" in json));
+		ok(!JSON.stringify(json).includes("dc:license"));
+	}
+	const parsedNote = await Note.fromJsonLd(noteExample, { documentLoader: noFetch });
+	const forwarded = record(await new Create({
+		actor: new URL("https://social.example/user/1753"),
+		object: parsedNote
+	}).toJsonLd());
+	deepStrictEqual(contexts(forwarded).at(-1), FEP);
+	deepStrictEqual(record(forwarded.object).license, BY);
+	const question = record(await new Question({
+		id: new URL("https://social.example/question/1"),
+		licenses: [new URL(BY)]
+	}).toJsonLd());
+	deepStrictEqual(question.license, BY);
+	ok(!JSON.stringify(question).includes("dc:license"));
+	const inline = await Note.fromJsonLd({
+		"@context": [AS, { license: {
+			"@id": DC_LICENSE,
+			"@type": "@id"
+		} }],
+		id: "https://social.example/note/inline",
+		type: "Note",
+		license: BY
+	}, { documentLoader: noFetch });
+	const collection = record(await new Collection({
+		id: new URL("https://social.example/collection/1"),
+		items: [inline],
+		summary: "Licensed items"
+	}).toJsonLd());
+	deepStrictEqual(contexts(collection).at(-1), FEP);
+	const items = collection.items;
+	deepStrictEqual(items.license, BY);
+});
+test("FEP-6757 licenses of nested objects only", async () => {
+	const json = record(await new Note({
+		id: new URL("https://social.example/note/2"),
+		attachments: [new Link({
+			href: new URL(noteExample.attachment.href),
+			licenses: []
+		}), new Link({
+			href: new URL(noteExample.attachment.href),
+			licenses: [new URL(PD_MARK)]
+		})]
+	}).toJsonLd());
+	ok(!("license" in json));
+	const attachments = json.attachment;
+	ok(!("license" in attachments[0]));
+	deepStrictEqual(attachments[1].license, PD_MARK);
+	const links = (await expand(json))["https://www.w3.org/ns/activitystreams#attachment"];
+	deepStrictEqual(links[1][DC_LICENSE], [{ "@id": PD_MARK }]);
+	const person = record(await new Person({
+		id: new URL("https://social.example/user/1"),
+		icon: new Image({ licenses: [new URL(BY_NC)] })
+	}).toJsonLd());
+	ok(!("license" in person));
+	deepStrictEqual(record(person.icon).license, BY_NC);
+	const collection = await Collection.fromJsonLd({
+		"@context": [AS, FEP],
+		type: "Collection",
+		license: CC0,
+		items: [{
+			type: "Note",
+			content: "Unlicensed item"
+		}]
+	}, { documentLoader: noFetch });
+	deepStrictEqual(collection.licenses, [new URL(CC0)]);
+	const items = await Array.fromAsync(collection.getItems({ documentLoader: noFetch }));
+	ok(items[0] instanceof Note);
+	deepStrictEqual(items[0].licenses, []);
+});
+test("FEP-6757 modified clones write the canonical property", async () => {
+	const parsed = await Note.fromJsonLd({
+		"@context": [AS, { schema: "https://schema.org/" }],
+		id: "https://social.example/note/3",
+		type: "Note",
+		"schema:license": BY
+	}, { documentLoader: noFetch });
+	deepStrictEqual(parsed.licenses, [new URL(BY)]);
+	for (const clone of [parsed.clone({ content: "Edited" }), parsed.clone({ licenses: [new URL(CC0)] })]) {
+		const json = record(await clone.toJsonLd());
+		ok(!("schema:license" in json));
+		const expanded = await expand(json);
+		ok(!(SCHEMA_LICENSE in expanded));
+		deepStrictEqual(expanded[DC_LICENSE], [{ "@id": clone.licenses[0].href }]);
+	}
+	const compact = await expand(await parsed.toJsonLd({ format: "compact" }));
+	deepStrictEqual(compact[DC_LICENSE], [{ "@id": BY }]);
+	ok(!(SCHEMA_LICENSE in compact));
+});
+test("FEP-6757 caller-provided contexts", async () => {
+	for (const context of [
+		AS,
+		[AS, FEP],
+		[AS, "http://schema.org/"],
+		[
+			AS,
+			FEP,
+			"http://schema.org/"
+		],
+		[
+			AS,
+			"http://schema.org/",
+			FEP
+		]
+	]) {
+		const json = await note().toJsonLd({
+			format: "compact",
+			context
+		});
+		deepStrictEqual(record(json)["@context"], context);
+		deepStrictEqual((await expand(json))[DC_LICENSE], [{ "@id": BY }]);
+		deepStrictEqual((await Note.fromJsonLd(json, { documentLoader: noFetch })).licenses, [new URL(BY)]);
+	}
+});
+test("FEP-6757 synonym precedence", async () => {
+	const id = "https://social.example/note/4";
+	const cases = [
+		[{
+			[DC_LICENSE]: [{ "@id": BY }],
+			[SCHEMA_LICENSE]: [{ "@id": CC0 }]
+		}, [BY]],
+		[{
+			[SCHEMA_LICENSE]: [{ "@id": CC0 }],
+			[CC_LICENSE]: [{ "@id": BY }]
+		}, [CC0]],
+		[{ [HTTP_SCHEMA_LICENSE]: [{ "@id": BY }] }, []],
+		[{ [CC_LICENSE]: [{ "@id": CC0 }, { "@value": BY }] }, [CC0, BY]],
+		[{
+			[DC_LICENSE]: [],
+			[SCHEMA_LICENSE]: [{ "@value": BY }]
+		}, [BY]],
+		[{
+			[DC_LICENSE]: [{ "@id": "CC-BY-4.0" }],
+			[SCHEMA_LICENSE]: [{ "@id": BY }]
+		}, []],
+		[{}, []]
+	];
+	for (const [properties, expected] of cases) deepStrictEqual((await Note.fromJsonLd({
+		"@id": id,
+		"@type": [`${AS}#Note`],
+		...properties
+	}, { documentLoader: noFetch })).licenses, expected.map((l) => new URL(l)));
+});
+test("FEP-6757 schema.org context order", async () => {
+	for (const [context, predicate, expected] of [[
+		[
+			AS,
+			FEP,
+			"http://schema.org/"
+		],
+		HTTP_SCHEMA_LICENSE,
+		[]
+	], [
+		[
+			AS,
+			"http://schema.org/",
+			FEP
+		],
+		DC_LICENSE,
+		[new URL(BY)]
+	]]) {
+		const json = {
+			"@context": context,
+			id: "https://social.example/note/5",
+			type: "Note",
+			license: BY
+		};
+		deepStrictEqual(Object.keys(await expand(json)).includes(predicate), true);
+		deepStrictEqual((await Note.fromJsonLd(json, {
+			documentLoader: noFetch,
+			contextLoader: offlineContextLoader()
+		})).licenses, expected);
+	}
+	for (const extra of [{}, { "@language": "und" }]) deepStrictEqual((await Note.fromJsonLd({
+		"@context": [AS, {
+			schema: "https://schema.org/",
+			...extra
+		}],
+		type: "Note",
+		"schema:license": BY
+	}, { documentLoader: noFetch })).licenses, [new URL(BY)]);
+});
+test("FEP-6757 PeerTube licences round-trip unchanged", async () => {
+	const video = {
+		"@context": [AS, {
+			sc: "http://schema.org/",
+			licence: "sc:license",
+			uuid: "sc:identifier"
+		}],
+		type: "Video",
+		id: "https://peertube.example/videos/watch/1",
+		name: "A video",
+		uuid: "e5a2d4b0-0000-4000-8000-000000000000",
+		licence: {
+			identifier: "1",
+			name: "Attribution"
+		}
+	};
+	const parsed = await Video.fromJsonLd(video, { documentLoader: noFetch });
+	deepStrictEqual(parsed.licenses, []);
+	deepStrictEqual(await parsed.toJsonLd(), video);
+	const create = {
+		"@context": video["@context"],
+		type: "Create",
+		id: "https://peertube.example/videos/watch/1/activity",
+		actor: "https://peertube.example/accounts/alice",
+		object: {
+			...video,
+			"@context": void 0
+		}
+	};
+	delete create.object["@context"];
+	deepStrictEqual(await (await Create.fromJsonLd(create, { documentLoader: noFetch })).toJsonLd(), create);
+});
+test("FEP-6757 rejects license names and relative identifiers", async () => {
+	const base = {
+		"@context": [AS, FEP],
+		id: "https://social.example/note/6",
+		type: "Note"
+	};
+	for (const license of [
+		"CC-BY-4.0",
+		"Creative Commons Attribution 4.0 International",
+		"licenses/by/4.0/",
+		"_:license"
+	]) {
+		const parsed = await Note.fromJsonLd({
+			...base,
+			license
+		}, { documentLoader: noFetch });
+		deepStrictEqual(parsed.licenses, []);
+		ok(!("license" in record(await parsed.toJsonLd())));
+	}
+	const mixed = await Note.fromJsonLd({
+		...base,
+		license: [
+			"CC-BY-4.0",
+			BY,
+			"urn:example:license"
+		]
+	}, { documentLoader: noFetch });
+	deepStrictEqual(mixed.licenses, [new URL(BY), new URL("urn:example:license")]);
+	deepStrictEqual(record(await mixed.toJsonLd()).license, [BY, "urn:example:license"]);
+	deepStrictEqual((await Note.fromJsonLd({
+		...base,
+		"@context": [
+			AS,
+			FEP,
+			{ "@base": "https://licenses.example/" }
+		],
+		license: "by/4.0/"
+	}, { documentLoader: noFetch })).licenses, [new URL("https://licenses.example/by/4.0/")]);
+	for (const value of [{
+		"@value": BY,
+		"@type": "http://www.w3.org/2001/XMLSchema#date"
+	}, {
+		"@value": "CC-BY-4.0",
+		"@language": "en"
+	}]) deepStrictEqual((await Note.fromJsonLd({
+		"@type": [`${AS}#Note`],
+		[DC_LICENSE]: [value]
+	}, { documentLoader: noFetch })).licenses, []);
+	deepStrictEqual((await Note.fromJsonLd({
+		"@type": [`${AS}#Note`],
+		[DC_LICENSE]: [{
+			"@value": BY,
+			"@type": "http://www.w3.org/2001/XMLSchema#anyURI"
+		}]
+	}, { documentLoader: noFetch })).licenses, [new URL(BY)]);
+});
+test("FEP-6757 license IRIs are never dereferenced", async () => {
+	const requested = [];
+	const documentLoader = (url) => {
+		requested.push(url);
+		throw new Error(`Unexpected fetch: ${url}`);
+	};
+	const contextLoader = offlineContextLoader();
+	const parsed = await Note.fromJsonLd(noteExample, {
+		documentLoader,
+		contextLoader
+	});
+	deepStrictEqual(parsed.licenses, [new URL(BY)]);
+	await parsed.clone({ content: "Edited" }).toJsonLd({ contextLoader });
+	deepStrictEqual((await Person.fromJsonLd(personExample, {
+		documentLoader,
+		contextLoader
+	})).preferredLicense, new URL(BY_NC));
+	deepStrictEqual(requested, []);
+	for (const url of contextLoader.loaded) ok(url in preloadedContexts);
+});
+//#endregion
+export {};

package/dist-tests/link.yaml

@@ -112,3 +112,28 @@ properties:
   range:
   - "https://www.w3.org/ns/activitystreams#Link"
   - "https://www.w3.org/ns/activitystreams#Object"
+
+- pluralName: licenses
+  singularName: license
+  compactName: license
+  uri: "http://purl.org/dc/terms/license"
+  extraContext: "https://w3id.org/fep/6757"
+  redundantProperties:
+  - uri: "https://schema.org/license"
+  - uri: "http://creativecommons.org/ns#license"
+  redundantPropertiesWrite: canonical
+  description: |
+    The copyright licenses for the linked resource, as defined by
+    [FEP-6757](https://w3id.org/fep/6757).  Each license is identified by its
+    URI, such as <https://creativecommons.org/publicdomain/mark/1.0/>; license
+    names and SPDX short identifiers are not license URIs.  Multiple values are
+    alternatives that a consumer may choose from; their order has no meaning.
+
+    An empty list means the link carries no license metadata.  Fedify does not
+    synthesize a default license for it.
+
+    The `https://schema.org/license` and
+    `http://creativecommons.org/ns#license` properties are read as synonyms
+    when this property is absent, but only this property is written.
+  range:
+  - "fedify:absoluteIri"

package/dist-tests/{lookup-CIDHxy5l.mjs → lookup-DKLMyPMJ.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1 } from "./vocab-EFWWufqL.mjs";
-import { i as isActor, o as name, s as version } from "./actor-DpNkhFU9.mjs";
+import { A as Object$1 } from "./vocab-Cg2PG-xH.mjs";
+import { i as isActor, o as name, s as version } from "./actor-BbIjMjNa.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";

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-EFWWufqL.mjs";
-import { t as esm_default } from "./esm-Cncdk-Cm.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-CIDHxy5l.mjs";
+import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-Cg2PG-xH.mjs";
+import { t as esm_default } from "./esm-rg6f9oLR.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-DKLMyPMJ.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";