@fedify/vocab 2.4.0-dev.2077 → 2.4.0-dev.2093

package/deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab",
-  "version": "2.4.0-dev.2077+c29a03d4",
+  "version": "2.4.0-dev.2093+e9706a54",
   "license": "MIT",
   "exports": {
     ".": "./src/mod.ts"

package/dist/mod.cjs

@@ -36,7 +36,7 @@ let _fedify_vocab_runtime_temporal = require("@fedify/vocab-runtime/temporal");
 let es_toolkit = require("es-toolkit");
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.4.0-dev.2077+c29a03d4";
+var version = "2.4.0-dev.2093+e9706a54";
 //#endregion
 //#region src/type.ts
 function getTypeId(object) {

package/dist/mod.js

@@ -12,7 +12,7 @@ import { isTemporalDuration, isTemporalInstant } from "@fedify/vocab-runtime/tem
 import { delay } from "es-toolkit";
 //#region deno.json
 var name = "@fedify/vocab";
-var version = "2.4.0-dev.2077+c29a03d4";
+var version = "2.4.0-dev.2093+e9706a54";
 //#endregion
 //#region src/type.ts
 function getTypeId(object) {

package/dist-tests/{actor-BvcvJ4UX.mjs → actor-BqI2hrlv.mjs}

@@ -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.2077+c29a03d4";
+var version = "2.4.0-dev.2093+e9706a54";
 //#endregion
 //#region src/actor.ts
 const ACTOR_DISCOVERY_HISTOGRAM_BUCKETS = [

package/dist-tests/actor.test.mjs

@@ -2,7 +2,7 @@ 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-BHtBRusa.mjs";
 import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-BvcvJ4UX.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-BqI2hrlv.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/gateway.test.mjs

@@ -2,7 +2,7 @@ import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { F as Person, M as OrderedCollection, c as CollectionPage, k as Note, s as Collection, u as Create } from "./vocab-BHtBRusa.mjs";
 import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as traverseCollection } from "./lookup-K74BlMOT.mjs";
+import { n as traverseCollection } from "./lookup-bESEuLBl.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, ok, rejects } from "node:assert/strict";
@@ -165,7 +165,8 @@ test("getObject() rejects objects with a mismatching portable ID", async (t) =>
 		"another path": `ap://${did}/objects/2`,
 		"a dot segment": `ap://${did}/objects/x/../1`,
 		"a fragment": `ap://${did}/objects/1#fragment`,
-		"a compatible identifier": `https://gw1.example${gatewayPath}`,
+		"a compatible identifier of another DID": `https://gw1.example/.well-known/apgateway/did:key:z6Mkdef/objects/1`,
+		"a compatible identifier of another path": `https://gw1.example/.well-known/apgateway/${did}/objects/2`,
 		"an HTTP(S) ID": "https://gw1.example/objects/1"
 	};
 	for (const [name, id] of globalThis.Object.entries(mismatches)) await t.step(name, async () => {
@@ -856,14 +857,14 @@ test("accessors reject forged objects at compatible identifiers", async () => {
 		"ignore",
 		"trust"
 	]) {
-		const verifier = createRecordingVerifier();
+		const verifier = createRecordingVerifier(() => ({ verified: false }));
 		deepStrictEqual(await (await createHttpActivity(forgedId)).getObject({
 			documentLoader: createLoader({ [forgedId]: forged }),
 			contextLoader: mockDocumentLoader,
 			verifyPortableObject: verifier,
 			crossOrigin
 		}), null);
-		deepStrictEqual(verifier.calls, []);
+		deepStrictEqual(verifier.calls.map((c) => c.document), [forged]);
 		deepStrictEqual(await (await createHttpActivity(forgedId)).getObject({
 			documentLoader: createLoader({ [forgedId]: note() }),
 			contextLoader: mockDocumentLoader,
@@ -923,7 +924,7 @@ test("accessors keep fetching compatible identifiers as HTTP(S) URLs without ver
 		deepStrictEqual(await activity.getObject({
 			documentLoader,
 			contextLoader: mockDocumentLoader,
-			verifyPortableObject: createVerifier()
+			verifyPortableObject: createVerifier(false)
 		}), null);
 		deepStrictEqual(documentLoader.fetched, [compatibleNoteId, compatibleNoteId]);
 	});
@@ -937,7 +938,7 @@ test("accessors keep fetching compatible identifiers as HTTP(S) URLs without ver
 		deepStrictEqual(await Array.fromAsync(activity.getObjects({
 			documentLoader,
 			contextLoader: mockDocumentLoader,
-			verifyPortableObject: createVerifier()
+			verifyPortableObject: createVerifier(false)
 		})), []);
 	});
 	await t.step("redirects to ordinary objects", async () => {
@@ -1066,7 +1067,7 @@ test("accessors verify fetched documents that stand for portable objects", async
 	await t.step("a document that claims another object", async () => {
 		for (const id of [
 			`ap://${did}/objects/2`,
-			compatibleNoteId,
+			gatewayUrl("https://gw.example", "/objects/2"),
 			"https://gw.example/notes/1"
 		]) {
 			const verifier = createRecordingVerifier();
@@ -1101,12 +1102,20 @@ test("accessors verify fetched documents that stand for portable objects", async
 	await t.step("a compatible @id", async () => {
 		const verifier = createRecordingVerifier();
 		const url = "https://gw.example/notes/1";
-		deepStrictEqual(await (await createHttpActivity(url)).getObject({
-			documentLoader: createLoader({ [url]: note(compatibleNoteId) }),
+		const documentLoader = createLoader({ [url]: note(compatibleNoteId) });
+		const object = await (await createHttpActivity(url)).getObject({
+			documentLoader,
 			contextLoader: mockDocumentLoader,
 			verifyPortableObject: verifier
+		});
+		assertInstanceOf(object, Note);
+		deepStrictEqual(object.id, new URL(compatibleNoteId));
+		deepStrictEqual(verifier.calls.length, 1);
+		deepStrictEqual(await (await createHttpActivity(url)).getObject({
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false)
 		}), null);
-		deepStrictEqual(verifier.calls, []);
 	});
 	await t.step("a portable final URL", async () => {
 		for (const [id, expected] of [[objectId, true], [`ap://${did}/objects/2`, false]]) deepStrictEqual(await (await createHttpActivity(plainUrl)).getObject({

package/dist-tests/{lookup-K74BlMOT.mjs → lookup-bESEuLBl.mjs}

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

@@ -2,7 +2,7 @@ import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { A as Object$1, F as Person, k as Note, s as Collection } from "./vocab-BHtBRusa.mjs";
 import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as traverseCollection, t as lookupObject } from "./lookup-K74BlMOT.mjs";
+import { n as traverseCollection, t as lookupObject } from "./lookup-bESEuLBl.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

@@ -2,8 +2,8 @@ import "temporal-polyfill";
 globalThis.addEventListener = () => {};
 import { F as Person } from "./vocab-BHtBRusa.mjs";
 import { t as esm_default } from "./esm-C9nxP5_e.mjs";
-import { n as getActorHandle } from "./actor-BvcvJ4UX.mjs";
-import { t as lookupObject } from "./lookup-K74BlMOT.mjs";
+import { n as getActorHandle } from "./actor-BqI2hrlv.mjs";
+import { t as lookupObject } from "./lookup-bESEuLBl.mjs";
 import { t as assertInstanceOf } from "./utils-Df2odC27.mjs";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 import { deepStrictEqual, equal, rejects } from "node:assert/strict";
@@ -110,13 +110,29 @@ test("lookupObject() with FEP-ef61 portable actors", {
 			}), Person);
 			deepStrictEqual(documentLoader.fetched, [compatibleId, other]);
 		});
+		await t.step("accepts a compatible identifier as the ID", async () => {
+			esm_default.removeRoutes();
+			esm_default.get(webFingerPrefix, selfLinks(compatibleId));
+			const document = person(compatibleId);
+			const documentLoader = createLoader({ [compatibleId]: document });
+			const verifyPortableObject = createVerifier();
+			const actor = await lookupObject("@alice@example.com", {
+				documentLoader,
+				contextLoader: mockDocumentLoader,
+				verifyPortableObject
+			});
+			assertInstanceOf(actor, Person);
+			deepStrictEqual(actor.id, new URL(compatibleId));
+			deepStrictEqual(verifyPortableObject.documents, [document]);
+		});
 		await t.step("rejects objects that fail the checks", async () => {
 			esm_default.removeRoutes();
 			esm_default.get(webFingerPrefix, selfLinks(compatibleId));
 			for (const [document, verified] of [
 				[person(), false],
 				[person(`ap://${did}/other`), true],
-				[person(compatibleId), true]
+				[person(`https://example.com/.well-known/apgateway/${did}/other`), true],
+				[person(compatibleId), false]
 			]) {
 				const documentLoader = createLoader({ [compatibleId]: document });
 				const verifyPortableObject = createVerifier(verified);
@@ -390,14 +406,22 @@ test("lookupObject() verifies fetched documents that stand for portable objects"
 		}), null);
 	});
 	await t.step("a compatible @id", async () => {
-		const documentLoader = redirectingLoader(plainUrl, person(compatibleId));
+		const document = person(compatibleId);
+		const documentLoader = redirectingLoader(plainUrl, document);
 		const verifyPortableObject = createVerifier();
-		equal(await lookupObject(plainUrl, {
+		const verified = await lookupObject(plainUrl, {
 			documentLoader,
 			contextLoader: mockDocumentLoader,
 			verifyPortableObject
+		});
+		assertInstanceOf(verified, Person);
+		deepStrictEqual(verified.id, new URL(compatibleId));
+		deepStrictEqual(verifyPortableObject.documents, [document]);
+		equal(await lookupObject(plainUrl, {
+			documentLoader,
+			contextLoader: mockDocumentLoader,
+			verifyPortableObject: createVerifier(false)
 		}), null);
-		deepStrictEqual(verifyPortableObject.documents, []);
 		const actor = await lookupObject(plainUrl, {
 			documentLoader,
 			contextLoader: mockDocumentLoader

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-BHtBRusa.mjs";
-import "./actor-BvcvJ4UX.mjs";
-import "./lookup-K74BlMOT.mjs";
+import "./actor-BqI2hrlv.mjs";
+import "./lookup-bESEuLBl.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab",
-  "version": "2.4.0-dev.2077+c29a03d4",
+  "version": "2.4.0-dev.2093+e9706a54",
   "homepage": "https://fedify.dev/",
   "repository": {
     "type": "git",
@@ -43,9 +43,9 @@
     "jsonld": "^9.0.0",
     "pkijs": "^3.3.3",
     "temporal-polyfill": "^1.0.1",
-    "@fedify/vocab-tools": "2.4.0-dev.2077+c29a03d4",
-    "@fedify/webfinger": "2.4.0-dev.2077+c29a03d4",
-    "@fedify/vocab-runtime": "2.4.0-dev.2077+c29a03d4"
+    "@fedify/webfinger": "2.4.0-dev.2093+e9706a54",
+    "@fedify/vocab-tools": "2.4.0-dev.2093+e9706a54",
+    "@fedify/vocab-runtime": "2.4.0-dev.2093+e9706a54"
   },
   "devDependencies": {
     "@types/node": "^24.12.2",

package/src/gateway.test.ts

@@ -262,7 +262,10 @@ test("getObject() rejects objects with a mismatching portable ID", async (t) =>
     "another path": `ap://${did}/objects/2`,
     "a dot segment": `ap://${did}/objects/x/../1`,
     "a fragment": `ap://${did}/objects/1#fragment`,
-    "a compatible identifier": `https://gw1.example${gatewayPath}`,
+    "a compatible identifier of another DID":
+      `https://gw1.example/.well-known/apgateway/did:key:z6Mkdef/objects/1`,
+    "a compatible identifier of another path":
+      `https://gw1.example/.well-known/apgateway/${did}/objects/2`,
     "an HTTP(S) ID": "https://gw1.example/objects/1",
   };
   for (const [name, id] of globalThis.Object.entries(mismatches)) {
@@ -1239,8 +1242,10 @@ test("accessors reject forged objects at compatible identifiers", async () => {
     content: "Forged",
   };
   for (const crossOrigin of [undefined, "ignore", "trust"] as const) {
-    // Its @id is not a portable ID, so it fails the identity check:
-    const verifier = createRecordingVerifier();
+    // Its @id, the compatible identifier itself, stands for the requested
+    // portable object, so the proof policy decides, which rejects it for
+    // lacking a proof:
+    const verifier = createRecordingVerifier(() => ({ verified: false }));
     deepStrictEqual(
       await (await createHttpActivity(forgedId)).getObject({
         documentLoader: createLoader({ [forgedId]: forged }),
@@ -1250,7 +1255,7 @@ test("accessors reject forged objects at compatible identifiers", async () => {
       }),
       null,
     );
-    deepStrictEqual(verifier.calls, []);
+    deepStrictEqual(verifier.calls.map((c) => c.document), [forged]);
     // With a portable ID, it fails the proof policy:
     deepStrictEqual(
       await (await createHttpActivity(forgedId)).getObject({
@@ -1335,7 +1340,7 @@ test("accessors keep fetching compatible identifiers as HTTP(S) URLs without ver
       await activity.getObject({
         documentLoader,
         contextLoader: mockDocumentLoader,
-        verifyPortableObject: createVerifier(),
+        verifyPortableObject: createVerifier(false),
       }),
       null,
     );
@@ -1357,7 +1362,7 @@ test("accessors keep fetching compatible identifiers as HTTP(S) URLs without ver
       await Array.fromAsync(activity.getObjects({
         documentLoader,
         contextLoader: mockDocumentLoader,
-        verifyPortableObject: createVerifier(),
+        verifyPortableObject: createVerifier(false),
       })),
       [],
     );
@@ -1540,7 +1545,7 @@ test("accessors verify fetched documents that stand for portable objects", async
     for (
       const id of [
         `ap://${did}/objects/2`,
-        compatibleNoteId,
+        gatewayUrl("https://gw.example", "/objects/2"),
         "https://gw.example/notes/1",
       ]
     ) {
@@ -1583,17 +1588,27 @@ test("accessors verify fetched documents that stand for portable objects", async
   });
 
   await t.step("a compatible @id", async () => {
+    // The compatible identifier stands for the portable object, so the
+    // document is verified as that object, keeping its own @id:
     const verifier = createRecordingVerifier();
     const url = "https://gw.example/notes/1";
+    const documentLoader = createLoader({ [url]: note(compatibleNoteId) });
+    const object = await (await createHttpActivity(url)).getObject({
+      documentLoader,
+      contextLoader: mockDocumentLoader,
+      verifyPortableObject: verifier,
+    });
+    assertInstanceOf(object, Note);
+    deepStrictEqual(object.id, new URL(compatibleNoteId));
+    deepStrictEqual(verifier.calls.length, 1);
     deepStrictEqual(
       await (await createHttpActivity(url)).getObject({
-        documentLoader: createLoader({ [url]: note(compatibleNoteId) }),
+        documentLoader,
         contextLoader: mockDocumentLoader,
-        verifyPortableObject: verifier,
+        verifyPortableObject: createVerifier(false),
       }),
       null,
     );
-    deepStrictEqual(verifier.calls, []);
   });
 
   await t.step("a portable final URL", async () => {

package/src/portable-lookup.test.ts

@@ -143,6 +143,25 @@ test("lookupObject() with FEP-ef61 portable actors", {
       deepStrictEqual(documentLoader.fetched, [compatibleId, other]);
     });
 
+    await t.step("accepts a compatible identifier as the ID", async () => {
+      // Some publishers, e.g., tootik, identify their portable actors by
+      // compatible identifiers; the document is verified as the portable
+      // object, and keeps its own ID:
+      fetchMock.removeRoutes();
+      fetchMock.get(webFingerPrefix, selfLinks(compatibleId));
+      const document = person(compatibleId);
+      const documentLoader = createLoader({ [compatibleId]: document });
+      const verifyPortableObject = createVerifier();
+      const actor = await lookupObject("@alice@example.com", {
+        documentLoader,
+        contextLoader: mockDocumentLoader,
+        verifyPortableObject,
+      });
+      assertInstanceOf(actor, Person);
+      deepStrictEqual(actor.id, new URL(compatibleId));
+      deepStrictEqual(verifyPortableObject.documents, [document]);
+    });
+
     await t.step("rejects objects that fail the checks", async () => {
       fetchMock.removeRoutes();
       fetchMock.get(webFingerPrefix, selfLinks(compatibleId));
@@ -151,8 +170,13 @@ test("lookupObject() with FEP-ef61 portable actors", {
           [person(), false],
           // Same DID, but another object:
           [person(`ap://${did}/other`), true],
-          // A compatible identifier as the object ID is not portable:
-          [person(compatibleId), true],
+          // A compatible identifier of another object:
+          [
+            person(`https://example.com/.well-known/apgateway/${did}/other`),
+            true,
+          ],
+          // A compatible identifier of the object, but unverified:
+          [person(compatibleId), false],
         ] as const
       ) {
         const documentLoader = createLoader({ [compatibleId]: document });
@@ -539,17 +563,26 @@ test("lookupObject() verifies fetched documents that stand for portable objects"
   });
 
   await t.step("a compatible @id", async () => {
-    const documentLoader = redirectingLoader(plainUrl, person(compatibleId));
+    const document = person(compatibleId);
+    const documentLoader = redirectingLoader(plainUrl, document);
+    // The document stands for the portable object, and is verified as it:
     const verifyPortableObject = createVerifier();
+    const verified = await lookupObject(plainUrl, {
+      documentLoader,
+      contextLoader: mockDocumentLoader,
+      verifyPortableObject,
+    });
+    assertInstanceOf(verified, Person);
+    deepStrictEqual(verified.id, new URL(compatibleId));
+    deepStrictEqual(verifyPortableObject.documents, [document]);
     equal(
       await lookupObject(plainUrl, {
         documentLoader,
         contextLoader: mockDocumentLoader,
-        verifyPortableObject,
+        verifyPortableObject: createVerifier(false),
       }),
       null,
     );
-    deepStrictEqual(verifyPortableObject.documents, []);
     // Without verifyPortableObject, it is fetched as before:
     const actor = await lookupObject(plainUrl, {
       documentLoader,