@fedify/vocab 2.5.0-dev.2504 → 2.5.0-dev.2516

package/dist-tests/{actor-BRLxkkip.mjs → actor-HAORUnb8.mjs}

@@ -1,14 +1,14 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
-import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-BmIsd6gR.mjs";
+import { F as Organization, I as Person, W as Service, a as Application, x as Group } from "./vocab-CCAqTuHd.mjs";
 import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, isGatewayUrl } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
 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.2504+fdeb138d";
+var version = "2.5.0-dev.2516+42d3ed0b";
 //#endregion
 //#region src/actor.ts
 const ACTOR_DISCOVERY_HISTOGRAM_BUCKETS = [

package/dist-tests/actor.test.mjs

@@ -2,8 +2,8 @@ import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { n as __exportAll } from "./rolldown-runtime-BWJg4WE8.mjs";
 import { t as esm_default } from "./esm-BIqRhjGA.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-BRLxkkip.mjs";
-import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-BmIsd6gR.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-HAORUnb8.mjs";
+import { F as Organization, I as Person, W as Service, a as Application, x as Group } from "./vocab-CCAqTuHd.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/deep-clone.test.mjs

@@ -0,0 +1,292 @@
+import { Temporal } from "temporal-polyfill";
+globalThis.addEventListener = () => {};
+import { A as Note, D as Link, G as Source, H as QuoteRequest, I as Person, U as Reject, f as DataIntegrityProof, h as Endpoints, j as Object$1, t as Accept, u as Create } from "./vocab-CCAqTuHd.mjs";
+import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { deepStrictEqual, notStrictEqual, ok, strictEqual, throws } from "node:assert/strict";
+import { LanguageString } from "@fedify/vocab-runtime";
+import { Buffer } from "node:buffer";
+//#region src/deep-clone.test.ts
+const options = { contextLoader: mockDocumentLoader };
+function personLoader(name, fetched = []) {
+	return async (url) => {
+		fetched.push(url);
+		return {
+			contextUrl: null,
+			documentUrl: url,
+			document: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: url,
+				type: "Person",
+				name
+			}
+		};
+	};
+}
+for (const hydrateOriginal of [false, true]) test(`deepClone() isolates embedded quote hydration (${hydrateOriginal})`, async () => {
+	const original = await QuoteRequest.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", { QuoteRequest: "https://w3id.org/fep/044f#QuoteRequest" }],
+		id: "https://a.example/requests/1",
+		type: "QuoteRequest",
+		instrument: {
+			id: "https://a.example/notes/1",
+			type: "Note",
+			attributedTo: "https://a.example/alice",
+			content: "Quoted"
+		}
+	}, {
+		...options,
+		documentLoader: personLoader("Alice")
+	});
+	const copy = original.deepClone();
+	const sourceNote = await original.getInstrument();
+	const copyNote = await copy.getInstrument();
+	ok(sourceNote instanceof Note && copyNote instanceof Note);
+	notStrictEqual(copyNote, sourceNote);
+	strictEqual((await (hydrateOriginal ? sourceNote : copyNote).getAttribution())?.name, "Alice");
+	for (const Wrapper of [Accept, Reject]) strictEqual((await new Wrapper({ object: hydrateOriginal ? copy : original }).toJsonLd(options)).object.instrument.attributedTo, "https://a.example/alice");
+	strictEqual(await original.getInstrument(), sourceNote);
+	strictEqual(await copy.getInstrument(), copyNote);
+});
+test("deepClone() copies replacements and preserves graph aliases", async () => {
+	const id = new URL("https://example.com/notes/1");
+	const child = new Note({
+		id,
+		url: id,
+		content: "Child"
+	});
+	const source = new Create({
+		object: child,
+		attachments: [child]
+	});
+	const copy = source.deepClone({ objects: [child, child] });
+	const objects = await Array.fromAsync(copy.getObjects());
+	const attachment = (await Array.fromAsync(copy.getAttachments()))[0];
+	strictEqual(objects[0], objects[1]);
+	strictEqual(objects[0], attachment);
+	notStrictEqual(objects[0], child);
+	strictEqual(objects[0].id, objects[0].url);
+	notStrictEqual(objects[0].id, id);
+	objects[0].id.pathname = "/changed";
+	strictEqual(id.pathname, "/notes/1");
+	strictEqual(await source.getObject(), child);
+	const backReference = source.deepClone({ object: source });
+	const snapshot = await backReference.getObject();
+	ok(snapshot instanceof Create);
+	notStrictEqual(snapshot, source);
+	notStrictEqual(snapshot, backReference);
+	ok(await snapshot.getObject() instanceof Note);
+	await backReference.toJsonLd(options);
+});
+test("deepClone() copies non-entity vocabulary objects and standalone roots", () => {
+	const endpoint = new URL("https://example.com/inbox");
+	const endpoints = new Endpoints({ sharedInbox: endpoint });
+	const source = new Source({ content: "Markdown" });
+	const copy = new Person({
+		endpoints,
+		source
+	}).deepClone();
+	notStrictEqual(copy.endpoints, endpoints);
+	notStrictEqual(copy.source, source);
+	notStrictEqual(copy.endpoints.sharedInbox, endpoint);
+	copy.endpoints.sharedInbox.pathname = "/copied";
+	strictEqual(endpoint.pathname, "/inbox");
+	const link = new Link({ href: endpoint }).deepClone();
+	notStrictEqual(link.href, endpoint);
+	strictEqual(link.href.href, endpoint.href);
+});
+test("deepClone() copies byte arrays including Buffer storage", async () => {
+	for (const bytes of [new Uint8Array([
+		1,
+		2,
+		3
+	]), Buffer.from([
+		1,
+		2,
+		3
+	])]) {
+		const proof = new DataIntegrityProof({ proofValue: bytes });
+		const copiedProof = await new Note({ proof }).deepClone().getProof();
+		ok(copiedProof instanceof DataIntegrityProof);
+		notStrictEqual(copiedProof, proof);
+		notStrictEqual(copiedProof.proofValue, bytes);
+		copiedProof.proofValue[0] = 9;
+		strictEqual(bytes[0], 1);
+		bytes[1] = 8;
+		strictEqual(copiedProof.proofValue[1], 2);
+	}
+});
+test("deepClone() shares immutable scalars and preserves sparse arrays", () => {
+	const content = new LanguageString("Hello", "en");
+	const published = Temporal.Instant.from("2026-10-27T00:00:00Z");
+	const names = new Array(3);
+	names[2] = "Kept";
+	const source = new Note({
+		names,
+		content,
+		published
+	});
+	const copy = source.deepClone();
+	strictEqual(copy.content, content);
+	strictEqual(copy.published, published);
+	deepStrictEqual(copy.names, source.names);
+	strictEqual(0 in copy.names, false);
+	copy.names.push("Copy only");
+	strictEqual(source.names.length, 3);
+});
+test("deepClone() retains node defaults and overrides only the root", async () => {
+	const fetched = [];
+	const [rootTracer, rootSpans] = createTestTracerProvider();
+	const [childTracer, childSpans] = createTestTracerProvider();
+	const child = new Note({ attribution: new URL("https://example.com/child-actor") }, {
+		...options,
+		documentLoader: personLoader("Child", fetched),
+		tracerProvider: childTracer
+	});
+	const source = new Create({
+		actor: new URL("https://example.com/root-actor"),
+		object: child
+	}, {
+		...options,
+		documentLoader: personLoader("Root", fetched),
+		tracerProvider: rootTracer
+	});
+	const copy = source.deepClone({}, { documentLoader: personLoader("Override") });
+	strictEqual((await copy.getActor())?.name, "Override");
+	const copiedChild = await copy.getObject();
+	ok(copiedChild instanceof Note);
+	strictEqual((await copiedChild.getAttribution())?.name, "Child");
+	strictEqual((await source.getActor())?.name, "Root");
+	deepStrictEqual(fetched, ["https://example.com/child-actor", "https://example.com/root-actor"]);
+	strictEqual(rootSpans.getSpans("activitypub.lookup_object").length, 2);
+	strictEqual(childSpans.getSpans("activitypub.lookup_object").length, 1);
+});
+test("deepClone() preserves origin checks and isolates hydrated trust", async () => {
+	let fetches = 0;
+	const original = await Create.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: "https://a.example/create",
+		type: "Create",
+		object: {
+			id: "https://b.example/note",
+			type: "Note",
+			content: "Embedded"
+		}
+	}, {
+		...options,
+		documentLoader: async (url) => {
+			fetches++;
+			return {
+				contextUrl: null,
+				documentUrl: url,
+				document: {
+					"@context": "https://www.w3.org/ns/activitystreams",
+					id: url,
+					type: "Note",
+					content: "Fetched"
+				}
+			};
+		}
+	});
+	strictEqual((await original.deepClone().getObject())?.content, "Fetched");
+	strictEqual(fetches, 1);
+	strictEqual((await original.getObject({ crossOrigin: "trust" }))?.content, "Embedded");
+	strictEqual((await original.getObject())?.content, "Fetched");
+	strictEqual(fetches, 2);
+});
+test("deepClone() keeps base URLs and discards cached JSON-LD", async () => {
+	const source = await Note.fromJsonLd({
+		"@context": ["https://www.w3.org/ns/activitystreams", { extension: "https://example.com/extension" }],
+		type: "Note",
+		id: "./note",
+		attributedTo: "./alice",
+		extension: "received only"
+	}, {
+		...options,
+		baseUrl: new URL("https://example.com/posts/"),
+		documentLoader: personLoader("Alice")
+	});
+	const copy = source.deepClone({ content: "Copy" });
+	strictEqual(copy.id.href, "https://example.com/posts/note");
+	strictEqual((await copy.getAttribution())?.id?.href, "https://example.com/posts/alice");
+	const json = await copy.toJsonLd(options);
+	strictEqual(json.content, "Copy");
+	strictEqual(json.extension, void 0);
+	strictEqual((await source.toJsonLd()).extension, "received only");
+});
+test("deepClone() validates replacements through clone() only", () => {
+	const source = new Note({ content: "Source" });
+	for (const values of [
+		{ id: 42 },
+		{
+			name: "one",
+			names: ["two"]
+		},
+		{ names: [42] }
+	]) throws(() => source.deepClone(values), TypeError);
+	function values(counter) {
+		return Object.create({ get content() {
+			counter.reads++;
+			return "Inherited";
+		} });
+	}
+	const shallowReads = { reads: 0 };
+	const deepReads = { reads: 0 };
+	strictEqual(source.clone(values(shallowReads)).content, "Inherited");
+	strictEqual(source.deepClone(values(deepReads)).content, "Inherited");
+	strictEqual(deepReads.reads, shallowReads.reads);
+});
+test("deepClone() preserves user subclasses and handles deep graphs", async () => {
+	class CustomNote extends Note {}
+	const child = new CustomNote({ content: "Child" });
+	const copiedChild = await new Create({ object: child }).deepClone().getObject();
+	ok(copiedChild instanceof CustomNote);
+	notStrictEqual(copiedChild, child);
+	let source = new Note({ content: "End" });
+	for (let i = 0; i < 3e3; i++) source = new Note({ replyTarget: source });
+	let copy = source.deepClone();
+	for (let i = 0; i < 3e3; i++) {
+		const next = await copy.getReplyTarget();
+		ok(next instanceof Note);
+		copy = next;
+	}
+	strictEqual(copy.content, "End");
+});
+test("deepClone() rejects broken subclass clone results", () => {
+	class ReturnsSelf extends Note {
+		clone() {
+			return this;
+		}
+	}
+	const source = new ReturnsSelf({ id: new URL("https://example.com/note") });
+	const id = source.id;
+	throws(() => source.deepClone(), /fresh, compatible/);
+	strictEqual(source.id, id);
+	class Incompatible extends Note {
+		clone() {
+			return new Object$1({});
+		}
+	}
+	throws(() => new Incompatible({}).deepClone(), /fresh, compatible/);
+	class ReusesCopy extends Note {
+		static copy;
+		clone() {
+			return ReusesCopy.copy ??= super.clone();
+		}
+	}
+	const first = new ReusesCopy({ content: "First" });
+	const second = new ReusesCopy({ content: "Second" });
+	throws(() => new Create({ objects: [first, second] }).deepClone(), /fresh, compatible/);
+	strictEqual(first.content, "First");
+	strictEqual(second.content, "Second");
+	class Throws extends Note {
+		clone() {
+			throw new Error("Copy failed");
+		}
+	}
+	const child = new Throws({ content: "Unchanged" });
+	const parent = new Create({ object: child });
+	throws(() => parent.deepClone(), /Copy failed/);
+	strictEqual(child.content, "Unchanged");
+});
+//#endregion
+export {};

package/dist-tests/gateway.test.mjs

@@ -1,12 +1,12 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "./esm-BIqRhjGA.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-BmIsd6gR.mjs";
-import { r as traverseCollection, t as lookupObject } from "./lookup-C20BmzHy.mjs";
+import { A as Note, C as Image, I as Person, N as OrderedCollection, c as CollectionPage, s as Collection, u as Create } from "./vocab-CCAqTuHd.mjs";
+import { r as traverseCollection, t as lookupObject } from "./lookup-B9VbSKaj.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
-import { FetchError, getDocumentLoader, parseIri, withGatewayHints } from "@fedify/vocab-runtime";
+import { FetchError, formatIri, getDocumentLoader, parseIri, withGatewayHints } from "@fedify/vocab-runtime";
 //#region src/gateway.test.ts
 const did = "did:key:z6Mkabc";
 const objectId = `ap+ef61://${did}/objects/1`;
@@ -724,6 +724,73 @@ test("getFirst() passes the referrer chain and collection context", async () =>
 	deepStrictEqual(referrer?.referrer?.referrer?.acceptance, "verified");
 	ok(referrer?.referrer?.referrer?.referrer?.object === create);
 });
+test("deepClone() preserves historical ancestry independently of replacements", async () => {
+	const context = Object.freeze({});
+	const documentLoader = createLoader({
+		[gatewayUrl("https://gw.example", "/actor/outbox")]: portableCollection("/actor/outbox", {
+			attributedTo: `ap://${did}/actor`,
+			first: {
+				id: `ap://${did}/actor/outbox?page=1`,
+				type: "OrderedCollectionPage",
+				partOf: `ap://${did}/other/outbox`,
+				next: `ap://${did}/actor/outbox?page=2`
+			}
+		}),
+		[gatewayUrl("https://gw.example", "/actor/outbox?page=2")]: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: `ap://${did}/actor/outbox?page=2`,
+			type: "OrderedCollectionPage"
+		},
+		[gatewayUrl("https://gw.example", "/actor")]: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: `ap://${did}/actor`,
+			type: "Person",
+			name: "Fetched actor"
+		}
+	});
+	const verifier = createRecordingVerifier(() => ({
+		verified: true,
+		collectionContext: context
+	}));
+	const options = {
+		documentLoader,
+		contextLoader: mockDocumentLoader,
+		gateways: ["https://gw.example"],
+		verifyPortableObject: verifier
+	};
+	const actor = await Person.fromJsonLd({
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: `ap://${did}/actor`,
+		type: "Person",
+		outbox: `ap://${did}/actor/outbox`
+	}, { contextLoader: mockDocumentLoader });
+	const outbox = await actor.getOutbox(options);
+	assertInstanceOf(outbox, OrderedCollection);
+	const first = await outbox.getFirst(options);
+	assertInstanceOf(first, CollectionPage);
+	const copy = outbox.deepClone({
+		id: parseIri(`ap://${did}/other/outbox`),
+		attribution: parseIri(`ap://${did}/different-actor`)
+	});
+	const copiedFirst = await copy.getFirst(options);
+	assertInstanceOf(copiedFirst, CollectionPage);
+	ok(copiedFirst !== first);
+	await copiedFirst.getNext(options);
+	const referrer = verifier.calls.at(-1).options.referrer;
+	ok(referrer?.object === copiedFirst);
+	const history = referrer.referrer;
+	ok(history?.object instanceof OrderedCollection);
+	ok(history.object !== copy && history.object !== outbox);
+	deepStrictEqual(history.id, outbox.id);
+	deepStrictEqual(history.acceptance, void 0);
+	deepStrictEqual(history.collectionContext, void 0);
+	deepStrictEqual(history.object.attributionId, outbox.attributionId);
+	deepStrictEqual(copiedFirst.partOfId, first.partOfId);
+	ok(copiedFirst.partOfId.href !== history.id.href);
+	ok(history.referrer?.object === actor);
+	await history.object.getAttribution(options);
+	deepStrictEqual((await outbox.toJsonLd()).attributedTo, formatIri(outbox.attributionId));
+});
 test("accessors do not trust objects embedded in unsecured collections", async () => {
 	const itemPath = "/objects/1";
 	const options = {
@@ -763,7 +830,7 @@ test("accessors do not trust objects embedded in unsecured collections", async (
 	}))).length, 1);
 	const outbox3 = await (await createPerson()).getOutbox(options);
 	assertInstanceOf(outbox3, Collection);
-	deepStrictEqual(await Array.fromAsync(outbox3.clone().getItems({
+	for (const copy of [outbox3.clone(), outbox3.deepClone()]) deepStrictEqual(await Array.fromAsync(copy.getItems({
 		...options,
 		documentLoader: createLoader({}),
 		suppressError: true

package/dist-tests/license.test.mjs

@@ -1,7 +1,7 @@
 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-BmIsd6gR.mjs";
-import "./src-CB6Qo4bK.mjs";
+import { A as Note, B as Question, C as Image, D as Link, F as Organization, I as Person, W as Service, Y as Video, a as Application, s as Collection, u as Create, x as Group } from "./vocab-CCAqTuHd.mjs";
+import "./src-sHf6TARh.mjs";
 import { test } from "@fedify/fixture";
 import { deepStrictEqual, ok } from "node:assert/strict";
 import { getDocumentLoader, preloadedContexts } from "@fedify/vocab-runtime";

package/dist-tests/{lookup-C20BmzHy.mjs → lookup-B9VbSKaj.mjs}

@@ -1,8 +1,8 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { i as isActor, o as name, s as version } from "./actor-BRLxkkip.mjs";
+import { i as isActor, o as name, s as version } from "./actor-HAORUnb8.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
-import { A as Object$1 } from "./vocab-BmIsd6gR.mjs";
+import { j as Object$1 } from "./vocab-CCAqTuHd.mjs";
 import { canonicalizePortableUri, formatIri, getDocumentLoader, haveSameFe34Origin, haveSameIriOrigin, parseIri } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
 import { SpanStatusCode, trace } from "@opentelemetry/api";

package/dist-tests/lookup.test.mjs

@@ -1,8 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "./esm-BIqRhjGA.mjs";
-import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-BmIsd6gR.mjs";
-import { n as lookupObserver, r as traverseCollection, t as lookupObject } from "./lookup-C20BmzHy.mjs";
+import { A as Note, I as Person, j as Object$1, s as Collection } from "./vocab-CCAqTuHd.mjs";
+import { n as lookupObserver, r as traverseCollection, t as lookupObject } from "./lookup-B9VbSKaj.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, ok, rejects } from "node:assert/strict";

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

@@ -1,9 +1,9 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { t as esm_default } from "./esm-BIqRhjGA.mjs";
-import { n as getActorHandle } from "./actor-BRLxkkip.mjs";
-import { F as Person } from "./vocab-BmIsd6gR.mjs";
-import { t as lookupObject } from "./lookup-C20BmzHy.mjs";
+import { n as getActorHandle } from "./actor-HAORUnb8.mjs";
+import { I as Person } from "./vocab-CCAqTuHd.mjs";
+import { t as lookupObject } from "./lookup-B9VbSKaj.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, rejects } from "node:assert/strict";

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

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { M as OrderedCollection, Z as vocab_exports, i as Announce, k as Note, u as Create, z as Question } from "./vocab-BmIsd6gR.mjs";
+import { A as Note, B as Question, N as OrderedCollection, Q as vocab_exports, i as Announce, u as Create } from "./vocab-CCAqTuHd.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok } from "node:assert/strict";
 import { isMarkerSafeContext, retainSignedRepresentation } from "@fedify/vocab-runtime/internal/signed-representation";
@@ -135,6 +135,20 @@ test("a clone does not inherit a retained signed representation", async () => {
 	deepStrictEqual(embedded["@context"], void 0);
 	deepStrictEqual(embedded.content, "Changed");
 });
+test("deepClone() drops retained signed representations at every level", async () => {
+	const note = retainedNote();
+	const original = new Create({ object: note });
+	retainSignedRepresentation(original, {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		type: "Create",
+		content: "Retained root only"
+	});
+	const json = await new Create({ object: original.deepClone() }).toJsonLd(options);
+	deepStrictEqual(json.object.content, void 0);
+	deepStrictEqual(json.object.object.content, "Hello");
+	deepStrictEqual(json.object.object.proof, void 0);
+	deepStrictEqual((await new Create({ object: note }).toJsonLd(options)).object, securedNote);
+});
 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);