@fedify/vocab 2.4.0-dev.2129 → 2.4.0-dev.2149

package/dist-tests/{actor-Jl479WDt.mjs → actor-DN2WrU71.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-DFtGFGsb.mjs";
+import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-CVEaA48h.mjs";
 import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
 import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, isGatewayUrl } from "@fedify/vocab-runtime";
 import { lookupWebFinger } from "@fedify/webfinger";
@@ -8,7 +8,7 @@ import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { domainToASCII, domainToUnicode } from "node:url";
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.4.0-dev.2129+c0ddb433";
+var version = "2.4.0-dev.2149+e2302034";
 //#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-DFtGFGsb.mjs";
-import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-Jl479WDt.mjs";
+import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-CVEaA48h.mjs";
+import { t as esm_default } from "./esm-CxYTzURx.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-DN2WrU71.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
 //#region ../../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/check/precondition/PreconditionFailure.js

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

@@ -1,6 +1,6 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { $ as __toESM, Z as __commonJSMin } from "./vocab-DFtGFGsb.mjs";
+import { $ as __toESM, Z as __commonJSMin } from "./vocab-CVEaA48h.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-DFtGFGsb.mjs";
-import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-YM9st5n8.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-CVEaA48h.mjs";
+import { t as esm_default } from "./esm-CxYTzURx.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-BDzZ7cld.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
@@ -1481,10 +1481,11 @@ test("objects use the verifyPortableObject option they were parsed with by defau
 		}), Note);
 		deepStrictEqual(verifier.calls.length, 2);
 	});
-	await t.step("an explicit option applies to that call only", async () => {
+	await t.step("an explicit option is passed on to fetched objects", async () => {
 		const stored = createRecordingVerifier();
 		const given = createRecordingVerifier();
-		const object = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored })).getObject({
+		const activity = await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored });
+		const object = await activity.getObject({
 			documentLoader,
 			contextLoader: mockDocumentLoader,
 			verifyPortableObject: given
@@ -1496,18 +1497,8 @@ test("objects use the verifyPortableObject option they were parsed with by defau
 			contextLoader: mockDocumentLoader,
 			gateways: ["https://gw.example"]
 		});
-		deepStrictEqual([stored.calls.length, given.calls.length], [1, 1]);
-		const object2 = await (await createCompatibleActivity(compatibleNoteId)).getObject({
-			documentLoader,
-			contextLoader: mockDocumentLoader,
-			verifyPortableObject: given
-		});
-		assertInstanceOf(object2, Note);
-		await rejects(async () => await object2.getAttribution({
-			documentLoader,
-			contextLoader: mockDocumentLoader,
-			gateways: ["https://gw.example"]
-		}), TypeError);
+		deepStrictEqual([stored.calls.length, given.calls.length], [0, 2]);
+		ok(getDefaultVerifier(activity) === stored);
 	});
 	await t.step("lookupObject()", async () => {
 		const verifier = createRecordingVerifier();
@@ -1540,7 +1531,360 @@ test("objects use the verifyPortableObject option they were parsed with by defau
 			verifyPortableObject: verifier
 		})).getIcon({ documentLoader });
 		assertInstanceOf(icon, Image);
-		ok(icon._verifyPortableObject === verifier);
+		ok(getDefaultVerifier(icon) === verifier);
+	});
+});
+function getDefaultVerifier(object) {
+	return object._verifyPortableObject;
+}
+test("accessors pass the verifier of a call on to the objects they fetch", async (t) => {
+	const actorId = `ap://${did}/actor`;
+	const attributedNote = (id) => ({
+		...note(id),
+		attributedTo: actorId
+	});
+	const actor = {
+		"@context": "https://www.w3.org/ns/activitystreams",
+		id: actorId,
+		type: "Person",
+		inbox: `${actorId}/inbox`
+	};
+	const actorUrl = gatewayUrl("https://gw.example", "/actor");
+	const plainNoteUrl = "https://example.com/notes/1";
+	const plainActivityUrl = "https://example.com/activities/1";
+	const options = {
+		documentLoader: createLoader({
+			[compatibleNoteId]: attributedNote(compatibleNoteId),
+			[actorUrl]: actor,
+			[plainNoteUrl]: {
+				...attributedNote(plainNoteUrl),
+				id: plainNoteUrl
+			},
+			[plainActivityUrl]: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				type: "Create",
+				id: plainActivityUrl,
+				object: compatibleNoteId
+			}
+		}),
+		contextLoader: mockDocumentLoader
+	};
+	const secondHop = {
+		...options,
+		gateways: ["https://gw.example"]
+	};
+	await t.step("from objects without a default", async () => {
+		const roots = [
+			["constructed", async () => new Create({
+				id: new URL(gatewayUrl("https://gw.example", "/activities/1")),
+				object: new URL(compatibleNoteId)
+			}, { contextLoader: mockDocumentLoader })],
+			["parsed", () => createCompatibleActivity(compatibleNoteId)],
+			["looked up", async () => {
+				const found = await lookupObject(plainActivityUrl, options);
+				assertInstanceOf(found, Create);
+				return found;
+			}]
+		];
+		for (const [name, createRoot] of roots) {
+			const verifier = createRecordingVerifier();
+			const root = await createRoot();
+			ok(getDefaultVerifier(root) == null, name);
+			const object = await root.getObject({
+				...options,
+				verifyPortableObject: verifier
+			});
+			assertInstanceOf(object, Note);
+			deepStrictEqual(verifier.calls.length, 1, name);
+			assertInstanceOf(await object.getAttribution(secondHop), Person);
+			deepStrictEqual(verifier.calls.length, 2, name);
+			ok(getDefaultVerifier(root) == null, name);
+			const verifier2 = createRecordingVerifier();
+			const objects = await Array.fromAsync((await createRoot()).getObjects({
+				...options,
+				verifyPortableObject: verifier2
+			}));
+			deepStrictEqual(objects.length, 1, name);
+			assertInstanceOf(objects[0], Note);
+			const authors = await Array.fromAsync(objects[0].getAttributions(secondHop));
+			deepStrictEqual(authors.length, 1, name);
+			assertInstanceOf(authors[0], Person);
+			deepStrictEqual(verifier2.calls.length, 2, name);
+		}
+	});
+	await t.step("precedence", async () => {
+		const stored = createRecordingVerifier();
+		const given = createRecordingVerifier();
+		const override = createRecordingVerifier();
+		const counts = () => [
+			stored.calls.length,
+			given.calls.length,
+			override.calls.length
+		];
+		const byDefault = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored })).getObject({
+			...options,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(byDefault, Note);
+		ok(getDefaultVerifier(byDefault) === stored);
+		deepStrictEqual(counts(), [
+			1,
+			0,
+			0
+		]);
+		const optedOut = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored })).getObject({
+			...options,
+			verifyPortableObject: given,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(optedOut, Note);
+		deepStrictEqual(counts(), [
+			1,
+			1,
+			0
+		]);
+		ok(getDefaultVerifier(optedOut) === stored);
+		assertInstanceOf(await optedOut.getAttribution(secondHop), Person);
+		deepStrictEqual(counts(), [
+			2,
+			1,
+			0
+		]);
+		const noDefault = await (await createCompatibleActivity(compatibleNoteId)).getObject({
+			...options,
+			verifyPortableObject: given,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(noDefault, Note);
+		deepStrictEqual(counts(), [
+			2,
+			2,
+			0
+		]);
+		ok(getDefaultVerifier(noDefault) == null);
+		await rejects(async () => await noDefault.getAttribution(secondHop), TypeError);
+		const inherited = await (await createCompatibleActivity(compatibleNoteId, void 0, { verifyPortableObject: stored })).getObject({
+			...options,
+			verifyPortableObject: given
+		});
+		assertInstanceOf(inherited, Note);
+		deepStrictEqual(counts(), [
+			2,
+			3,
+			0
+		]);
+		ok(getDefaultVerifier(inherited) === given);
+		assertInstanceOf(await inherited.getAttribution({
+			...secondHop,
+			verifyPortableObject: override
+		}), Person);
+		deepStrictEqual(counts(), [
+			2,
+			3,
+			1
+		]);
+		const optedOuts = await Array.fromAsync((await createCompatibleActivity([compatibleNoteId], void 0, { verifyPortableObject: stored })).getObjects({
+			...options,
+			verifyPortableObject: given,
+			inheritPortableObjectVerifier: false
+		}));
+		deepStrictEqual(optedOuts.length, 1);
+		ok(getDefaultVerifier(optedOuts[0]) === stored);
+	});
+	await t.step("ordinary HTTP(S) responses", async () => {
+		const given = createRecordingVerifier();
+		const stored = createRecordingVerifier();
+		const object = await (await createHttpActivity(plainNoteUrl)).getObject({
+			...options,
+			verifyPortableObject: given
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(given.calls.length, 0);
+		ok(getDefaultVerifier(object) === given);
+		assertInstanceOf(await object.getAttribution(secondHop), Person);
+		deepStrictEqual(given.calls.length, 1);
+		const { referrer } = given.calls[0].options;
+		ok(referrer?.object === object);
+		deepStrictEqual(referrer?.acceptance, void 0);
+		const optedOut = await (await Create.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Create",
+			id: plainActivityUrl,
+			object: plainNoteUrl
+		}, {
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: stored
+		})).getObject({
+			...options,
+			verifyPortableObject: given,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(optedOut, Note);
+		ok(getDefaultVerifier(optedOut) === stored);
+	});
+	await t.step("HTTP(S) responses that stand for portable objects", async () => {
+		const redirecting = createRedirectingLoader({ [plainNoteUrl]: {
+			documentUrl: compatibleNoteId,
+			document: attributedNote(compatibleNoteId)
+		} });
+		const given = createRecordingVerifier();
+		const object = await (await createHttpActivity(plainNoteUrl)).getObject({
+			documentLoader: redirecting,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: given
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(given.calls.length, 1);
+		ok(getDefaultVerifier(object) === given);
+		const optedOut = await (await createHttpActivity(plainNoteUrl)).getObject({
+			documentLoader: redirecting,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: given,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(optedOut, Note);
+		deepStrictEqual(given.calls.length, 2);
+		ok(getDefaultVerifier(optedOut) == null);
+	});
+	await t.step("objects that were fetched without a verifier", async () => {
+		const activity = await createHttpActivity(compatibleNoteId);
+		const unverified = await activity.getObject(options);
+		assertInstanceOf(unverified, Note);
+		ok(getDefaultVerifier(unverified) == null);
+		const verifier = createRecordingVerifier();
+		const verified = await activity.getObject({
+			...options,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(verified, Note);
+		ok(verified !== unverified);
+		deepStrictEqual(verifier.calls.length, 1);
+		ok(getDefaultVerifier(verified) === verifier);
+	});
+	await t.step("property preprocessors", async () => {
+		const iconUrl = "https://example.com/icon";
+		const loader = createLoader({ [iconUrl]: {
+			"@context": "https://www.w3.org/ns/activitystreams",
+			type: "Link",
+			href: "https://example.com/icon.png"
+		} });
+		const createPerson = () => Person.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: "https://example.com/person",
+			type: "Person",
+			icon: iconUrl
+		}, { contextLoader: mockDocumentLoader });
+		const verifier = createVerifier();
+		const icon = await (await createPerson()).getIcon({
+			documentLoader: loader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		});
+		assertInstanceOf(icon, Image);
+		ok(getDefaultVerifier(icon) === verifier);
+		const optedOut = await (await createPerson()).getIcon({
+			documentLoader: loader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			inheritPortableObjectVerifier: false
+		});
+		assertInstanceOf(optedOut, Image);
+		ok(getDefaultVerifier(optedOut) == null);
+	});
+	await t.step("embedded objects keep the parent's default", async () => {
+		const embedded = attributedNote(`ap://${did}/objects/2`);
+		const withoutContext = { ...embedded };
+		delete withoutContext["@context"];
+		for (const [name, value] of [["with @context", embedded], ["without @context", withoutContext]]) for (const stored of [void 0, createRecordingVerifier()]) {
+			const given = createRecordingVerifier();
+			const object = await (await createCompatibleActivity(value, `ap://${did}/activities/1`, stored == null ? {} : { verifyPortableObject: stored })).getObject({
+				...options,
+				verifyPortableObject: given
+			});
+			assertInstanceOf(object, Note);
+			ok(getDefaultVerifier(object) === stored, name);
+			deepStrictEqual(given.calls.length, 0, name);
+		}
+	});
+	await t.step("cached objects", async () => {
+		const weak = createRecordingVerifier();
+		const strict = createRecordingVerifier();
+		for (const [first, second] of [[weak, strict], [strict, weak]]) {
+			const activity = await createCompatibleActivity(compatibleNoteId);
+			const object = await activity.getObject({
+				...options,
+				verifyPortableObject: first
+			});
+			assertInstanceOf(object, Note);
+			const before = second.calls.length;
+			const cached = await activity.getObject({
+				...options,
+				verifyPortableObject: second
+			});
+			ok(cached === object);
+			ok(getDefaultVerifier(cached) === first);
+			deepStrictEqual(second.calls.length, before);
+		}
+	});
+	await t.step("traverseCollection()", async () => {
+		const collectionUrl = "https://example.com/collection";
+		const pageUrl = "https://example.com/collection?page=1";
+		const loader = createLoader({
+			...Object.fromEntries([
+				compatibleNoteId,
+				actorUrl,
+				plainNoteUrl
+			].map((url) => [url, url === plainNoteUrl ? {
+				...attributedNote(plainNoteUrl),
+				id: plainNoteUrl
+			} : url === actorUrl ? actor : attributedNote(compatibleNoteId)])),
+			[pageUrl]: {
+				"@context": "https://www.w3.org/ns/activitystreams",
+				id: pageUrl,
+				type: "OrderedCollectionPage",
+				orderedItems: [
+					{
+						id: "https://example.com/notes/2",
+						type: "Note",
+						attributedTo: actorId
+					},
+					plainNoteUrl,
+					compatibleNoteId
+				]
+			}
+		});
+		const createCollection = () => OrderedCollection.fromJsonLd({
+			"@context": "https://www.w3.org/ns/activitystreams",
+			id: collectionUrl,
+			type: "OrderedCollection",
+			first: pageUrl
+		}, { contextLoader: mockDocumentLoader });
+		const verifier = createRecordingVerifier();
+		const items = await Array.fromAsync(traverseCollection(await createCollection(), {
+			documentLoader: loader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier
+		}));
+		deepStrictEqual(items.length, 3);
+		deepStrictEqual(verifier.calls.length, 1);
+		for (const item of items) {
+			assertInstanceOf(item, Note);
+			ok(getDefaultVerifier(item) === verifier);
+			assertInstanceOf(await item.getAttribution({
+				documentLoader: loader,
+				contextLoader: mockDocumentLoader,
+				gateways: ["https://gw.example"]
+			}), Person);
+		}
+		deepStrictEqual(verifier.calls.length, 4);
+		const optedOut = await Array.fromAsync(traverseCollection(await createCollection(), {
+			documentLoader: loader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: verifier,
+			inheritPortableObjectVerifier: false
+		}));
+		deepStrictEqual(optedOut.length, 3);
+		for (const item of optedOut) ok(getDefaultVerifier(item) == null);
 	});
 });
 //#endregion

package/dist-tests/{lookup-YM9st5n8.mjs → lookup-BDzZ7cld.mjs}

@@ -1,7 +1,7 @@
 import { Temporal } from "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { A as Object$1 } from "./vocab-DFtGFGsb.mjs";
-import { i as isActor, o as name, s as version } from "./actor-Jl479WDt.mjs";
+import { A as Object$1 } from "./vocab-CVEaA48h.mjs";
+import { i as isActor, o as name, s as version } from "./actor-DN2WrU71.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-DFtGFGsb.mjs";
-import { t as esm_default } from "./esm-CU6UbTlZ.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-YM9st5n8.mjs";
+import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-CVEaA48h.mjs";
+import { t as esm_default } from "./esm-CxYTzURx.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-BDzZ7cld.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, ok, rejects } from "node:assert/strict";

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

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

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

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

package/dist-tests/translation.test.mjs

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

package/dist-tests/type.test.mjs

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