@fedify/fedify 2.3.0-dev.1119 → 2.3.0-dev.1137

package/dist/{docloader-WsWfKaE5.mjs → docloader-BT89tyFr.mjs}

@@ -1,11 +1,11 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { o as validateCryptoKey } from "./key-BoWaYRHm.mjs";
-import { n as doubleKnock } from "./http-DUV8ysti.mjs";
+import { o as validateCryptoKey } from "./key-CkkMJBjF.mjs";
+import { n as doubleKnock } from "./http-Cyx5SNuu.mjs";
 import { getLogger } from "@logtape/logtape";
-import { curry } from "es-toolkit";
 import { UrlError, createActivityPubRequest, getRemoteDocument, logRequest, validatePublicUrl } from "@fedify/vocab-runtime";
+import { curry } from "es-toolkit";
 //#region src/utils/docloader.ts
 const logger = getLogger([
 	"fedify",

package/dist/federation/builder.test.mjs

@@ -1,12 +1,12 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as RouterError } from "../router-BT_F5748.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import { r as assertExists } from "../std__assert-BTEgfoJo.mjs";
-import { t as assertThrows } from "../assert_throws-4NwKEy2q.mjs";
-import { t as MemoryKvStore } from "../kv-QHE0oeM3.mjs";
-import { r as createFederationBuilder } from "../builder-Ond_h57y.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { r as assertExists } from "../std__assert-BBjXFNOb.mjs";
+import { t as assertThrows } from "../assert_throws-BOkhLGYc.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
+import { r as createFederationBuilder } from "../builder-BCkBXxky.mjs";
+import { DisallowedOperatorError, DisallowedVarSpecModifierError, DuplicateRouteVariableError, RouteTemplateOptionsNotMatchedError, RouterError } from "@fedify/uri-template";
 import { Activity, Note, Person } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/builder.test.ts
@@ -74,6 +74,21 @@ test("FederationBuilder", async (t) => {
 		assertEquals(impl.router.build("inbox", { identifier: "user1" }), "/users/user1/inbox");
 		await builder.build({ kv });
 	});
+	await t.step("should snapshot router state on build", async () => {
+		const builder = createFederationBuilder();
+		const kv = new MemoryKvStore();
+		const noteRouteName = `object:${Note.typeId.href}`;
+		builder.setActorDispatcher("/users/{identifier}", () => null);
+		const impl1 = await builder.build({ kv });
+		builder.setObjectDispatcher(Note, "/notes/{id}", () => null);
+		assertEquals(impl1.router.route("/notes/1"), null);
+		const impl2 = await builder.build({ kv });
+		assertEquals(impl2.router.route("/notes/1")?.name, noteRouteName);
+		impl1.router.add("/leaked/{id}", "leaked");
+		assertEquals(impl1.router.route("/leaked/1")?.name, "leaked");
+		assertEquals(impl2.router.route("/leaked/1"), null);
+		assertEquals((await builder.build({ kv })).router.route("/leaked/1"), null);
+	});
 	await t.step("should build with default options", async () => {
 		const builder = createFederationBuilder();
 		const kv = new MemoryKvStore();
@@ -89,15 +104,128 @@ test("FederationBuilder", async (t) => {
 		assertThrows(() => builder.setOutboxListeners("/users/{identifier}/outbox/{extra}"), RouterError);
 		assertThrows(() => builder.setOutboxListeners("/users/{identifier}/outbox/{identifier}"), RouterError);
 		const builderAfterInvalid = createFederationBuilder();
-		assertThrows(() => builderAfterInvalid.setOutboxListeners("/users/{identifier}/outbox/{extra}"), RouterError);
+		assertThrows(() => builderAfterInvalid.setOutboxListeners("/users/{identifier}/outbox/{extra}"), RouteTemplateOptionsNotMatchedError);
+		assertThrows(() => builderAfterInvalid.setOutboxListeners("/users/{identifier:3}/outbox"), DisallowedVarSpecModifierError);
+		assertThrows(() => builderAfterInvalid.setOutboxListeners("/users/{identifier*}/outbox"), DisallowedVarSpecModifierError);
+		assertThrows(() => builderAfterInvalid.setOutboxListeners("/users/{identifier,identifier}/outbox"), DuplicateRouteVariableError);
 		builderAfterInvalid.setOutboxListeners("/users/{identifier}/outbox");
 		const builder2 = createFederationBuilder();
-		builder2.setOutboxListeners("/users{/identifier}/outbox");
+		builder2.setOutboxListeners("/users/{identifier}/outbox");
 		assertThrows(() => builder2.setOutboxDispatcher("/actors/{identifier}/outbox", () => ({ items: [] })), RouterError);
 		const builder3 = createFederationBuilder();
-		assertThrows(() => builder3.setOutboxListeners("/users{?identifier}/outbox"), RouterError);
+		assertThrows(() => builder3.setOutboxListeners("/users{?identifier}/outbox"), DisallowedOperatorError);
+		const builder3a = createFederationBuilder();
+		assertThrows(() => builder3a.setOutboxListeners("/users{;identifier}/outbox"), DisallowedOperatorError);
+		const builder3b = createFederationBuilder();
+		assertThrows(() => builder3b.setOutboxListeners("/users{.identifier}/outbox"), DisallowedOperatorError);
 		const builder4 = createFederationBuilder();
-		assertThrows(() => builder4.setOutboxDispatcher("/users{?identifier}/outbox", () => ({ items: [] })), RouterError);
+		assertThrows(() => builder4.setOutboxDispatcher("/users{?identifier}/outbox", () => ({ items: [] })), DisallowedOperatorError);
+		const builder5 = createFederationBuilder();
+		assertThrows(() => builder5.setOutboxDispatcher("/users/{identifier:3}/outbox", () => ({ items: [] })), DisallowedVarSpecModifierError);
+	});
+	await t.step("rejects non-segment-boundary identifier operators at registration for required-identifier routes", () => {
+		assertThrows(() => createFederationBuilder().setActorDispatcher("/users{/identifier}", () => null), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setActorDispatcher("{/identifier}", () => null), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setActorDispatcher("/users/{/identifier}", () => null), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setActorDispatcher("/users{?identifier}", () => null), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setInboxListeners("/users{/identifier}/inbox"), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setOutboxListeners("/users{/identifier}/outbox"), DisallowedOperatorError);
+		assertThrows(() => createFederationBuilder().setActorDispatcher("/users/{identifier:3}", () => null), DisallowedVarSpecModifierError);
+		assertThrows(() => createFederationBuilder().setActorDispatcher("/users/{identifier*}", () => null), DisallowedVarSpecModifierError);
+		createFederationBuilder().setActorDispatcher("/users/{identifier}", () => null);
+		createFederationBuilder().setInboxListeners("/users/{identifier}/inbox");
+	});
+	await t.step("every required-identifier setter rejects every omissible operator", () => {
+		const omissibleExprs = [
+			"{/identifier}",
+			"{?identifier}",
+			"{;identifier}",
+			"{.identifier}"
+		];
+		const registrars = [
+			["setActorDispatcher", (expr) => createFederationBuilder().setActorDispatcher(`/users${expr}`, () => null)],
+			["setInboxListeners", (expr) => createFederationBuilder().setInboxListeners(`/users${expr}/inbox`)],
+			["setOutboxListeners", (expr) => createFederationBuilder().setOutboxListeners(`/users${expr}/outbox`)],
+			["setOutboxDispatcher", (expr) => createFederationBuilder().setOutboxDispatcher(`/users${expr}/outbox`, () => ({ items: [] }))],
+			["setFollowingDispatcher", (expr) => createFederationBuilder().setFollowingDispatcher(`/users${expr}/following`, () => ({ items: [] }))],
+			["setFollowersDispatcher", (expr) => createFederationBuilder().setFollowersDispatcher(`/users${expr}/followers`, () => ({ items: [] }))],
+			["setLikedDispatcher", (expr) => createFederationBuilder().setLikedDispatcher(`/users${expr}/liked`, () => ({ items: [] }))],
+			["setFeaturedDispatcher", (expr) => createFederationBuilder().setFeaturedDispatcher(`/users${expr}/featured`, () => ({ items: [] }))],
+			["setFeaturedTagsDispatcher", (expr) => createFederationBuilder().setFeaturedTagsDispatcher(`/users${expr}/tags`, () => ({ items: [] }))]
+		];
+		for (const [name, register] of registrars) {
+			for (const expr of omissibleExprs) assertThrows(() => register(expr), DisallowedOperatorError, void 0, `${name} must reject ${expr} at registration`);
+			register("{identifier}");
+		}
+	});
+	await t.step("empty or missing identifier segments produce a runtime no-match", async () => {
+		const kv = new MemoryKvStore();
+		const builder = createFederationBuilder();
+		builder.setActorDispatcher("/users/{identifier}", () => null);
+		builder.setInboxListeners("/users/{identifier}/inbox");
+		builder.setOutboxDispatcher("/users/{identifier}/outbox", () => ({ items: [] }));
+		builder.setObjectDispatcher(Note, "/notes/{id}", () => null);
+		const impl = await builder.build({ kv });
+		assertEquals(impl.router.route("/users/alice")?.name, "actor");
+		assertEquals(impl.router.route("/users/alice/inbox")?.name, "inbox");
+		assertEquals(impl.router.route("/users/alice/outbox")?.name, "outbox");
+		assertEquals(impl.router.route("/notes/1")?.name, `object:${Note.typeId.href}`);
+		assertEquals(impl.router.route("/users/"), null);
+		assertEquals(impl.router.route("/users//inbox"), null);
+		assertEquals(impl.router.route("/users//outbox"), null);
+		assertEquals(impl.router.route("/notes/"), null);
+	});
+	await t.step("object dispatcher optional-operator routes no-match when unbound", async () => {
+		const kv = new MemoryKvStore();
+		const objectName = `object:${Note.typeId.href}`;
+		const query = createFederationBuilder();
+		query.setObjectDispatcher(Note, "/notes{?id}", () => null);
+		const queryImpl = await query.build({ kv });
+		assertEquals(queryImpl.router.route("/notes"), null);
+		assertEquals(queryImpl.router.route("/notes?id=1")?.name, objectName);
+		const matrix = createFederationBuilder();
+		matrix.setObjectDispatcher(Note, "/notes{;id}", () => null);
+		const matrixImpl = await matrix.build({ kv });
+		assertEquals(matrixImpl.router.route("/notes"), null);
+		assertEquals(matrixImpl.router.route("/notes;id=1")?.name, objectName);
+		const label = createFederationBuilder();
+		label.setObjectDispatcher(Note, "/notes{.id}", () => null);
+		const labelImpl = await label.build({ kv });
+		assertEquals(labelImpl.router.route("/notes"), null);
+		assertEquals(labelImpl.router.route("/notes.1")?.name, objectName);
+	});
+	await t.step("custom collection routes no-match empty or unbound variables", async () => {
+		const kv = new MemoryKvStore();
+		const builder = createFederationBuilder();
+		builder.setCollectionDispatcher("samples", Note, "/groups/{id}", () => ({ items: [] }));
+		builder.setCollectionDispatcher("optionals", Note, "/optional-groups{?id}", () => ({ items: [] }));
+		builder.setCollectionDispatcher("matrixOptionals", Note, "/matrix-groups{;id}", () => ({ items: [] }));
+		builder.setCollectionDispatcher("labelOptionals", Note, "/label-groups{.id}", () => ({ items: [] }));
+		const impl = await builder.build({ kv });
+		assertEquals(impl.router.route("/groups/1"), {
+			name: "collection:samples",
+			values: { id: "1" },
+			template: "/groups/{id}"
+		});
+		assertEquals(impl.router.route("/optional-groups?id=1"), {
+			name: "collection:optionals",
+			values: { id: "1" },
+			template: "/optional-groups{?id}"
+		});
+		assertEquals(impl.router.route("/matrix-groups;id=1"), {
+			name: "collection:matrixOptionals",
+			values: { id: "1" },
+			template: "/matrix-groups{;id}"
+		});
+		assertEquals(impl.router.route("/label-groups.1"), {
+			name: "collection:labelOptionals",
+			values: { id: "1" },
+			template: "/label-groups{.id}"
+		});
+		assertEquals(impl.router.route("/groups/"), null);
+		assertEquals(impl.router.route("/optional-groups"), null);
+		assertEquals(impl.router.route("/matrix-groups"), null);
+		assertEquals(impl.router.route("/label-groups"), null);
 	});
 	await t.step("should pass build options correctly", async () => {
 		const builder = createFederationBuilder();

package/dist/federation/collection.test.mjs

@@ -1,9 +1,9 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-BTEgfoJo.mjs";
-import { n as digest, t as buildCollectionSynchronizationHeader } from "../collection-Cc3DVAhE.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { n as digest, t as buildCollectionSynchronizationHeader } from "../collection-CA3V5zyK.mjs";
 import { test } from "@fedify/fixture";
 import { decodeHex } from "byte-encodings/hex";
 //#region src/federation/collection.test.ts

package/dist/federation/handler.test.mjs

@@ -1,18 +1,18 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-BAE7AKLA.mjs";
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-BTEgfoJo.mjs";
-import { n as assertGreaterOrEqual } from "../assert_rejects-DQP-q39h.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
-import { r as parseAcceptSignature } from "../accept-CgDcxvjV.mjs";
-import { s as signRequest } from "../http-DUV8ysti.mjs";
-import { a as rsaPrivateKey3, c as rsaPublicKey3, s as rsaPublicKey2 } from "../keys-CSYsOMFG.mjs";
-import { t as MemoryKvStore } from "../kv-QHE0oeM3.mjs";
-import { c as handleActor, d as handleInbox, f as handleObject, h as respondWithObjectIfAcceptable, l as handleCollection, m as respondWithObject, o as createFederation, p as handleOutbox, u as handleCustomCollection } from "../middleware-t0jC8I99.mjs";
-import { t as ActivityListenerSet } from "../activity-listener-BeTGV3wc.mjs";
+import { n as createOutboxContext, r as createRequestContext, t as createInboxContext } from "../context-DVoTs_wM.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { n as assertGreaterOrEqual } from "../assert_rejects-DN60FHPX.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-DBC5X09g.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { r as parseAcceptSignature } from "../accept-CceiKpCy.mjs";
+import { s as signRequest } from "../http-Cyx5SNuu.mjs";
+import { a as rsaPrivateKey3, c as rsaPublicKey3, s as rsaPublicKey2 } from "../keys-C3kae-6B.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
+import { c as handleActor, d as handleInbox, f as handleObject, h as respondWithObjectIfAcceptable, l as handleCollection, m as respondWithObject, o as createFederation, p as handleOutbox, u as handleCustomCollection } from "../middleware-DQEgdr83.mjs";
+import { t as ActivityListenerSet } from "../activity-listener-tztVvlNb.mjs";
 import { Activity, Create, Note, Person, Tombstone } from "@fedify/vocab";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError } from "@fedify/vocab-runtime";

package/dist/federation/idempotency.test.mjs

@@ -1,12 +1,12 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-BTEgfoJo.mjs";
-import { n as ed25519PrivateKey, r as ed25519PublicKey, t as ed25519Multikey } from "../keys-CSYsOMFG.mjs";
-import { r as signObject } from "../proof-DhVuz4bc.mjs";
-import { t as MemoryKvStore } from "../kv-QHE0oeM3.mjs";
-import { o as createFederation } from "../middleware-t0jC8I99.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { n as ed25519PrivateKey, r as ed25519PublicKey, t as ed25519Multikey } from "../keys-C3kae-6B.mjs";
+import { r as signObject } from "../proof-DpwO1T4S.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
+import { o as createFederation } from "../middleware-DQEgdr83.mjs";
 import { Create, Follow, Person } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/federation/idempotency.test.ts

package/dist/federation/inbox.test.mjs

@@ -1,9 +1,9 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import { t as assertThrows } from "../assert_throws-4NwKEy2q.mjs";
-import { t as ActivityListenerSet } from "../activity-listener-BeTGV3wc.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { t as assertThrows } from "../assert_throws-BOkhLGYc.mjs";
+import { t as ActivityListenerSet } from "../activity-listener-tztVvlNb.mjs";
 import { Activity, Create, Invite, Offer, Update } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/inbox.test.ts

package/dist/federation/keycache.test.mjs

@@ -1,11 +1,11 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import { t as assertInstanceOf } from "../assert_instance_of-C4Ri6VuN.mjs";
-import { t as assert } from "../assert-DikXweDx.mjs";
-import { t as MemoryKvStore } from "../kv-QHE0oeM3.mjs";
-import { t as KvKeyCache } from "../keycache-BeU0LCII.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import { t as assertInstanceOf } from "../assert_instance_of-DBC5X09g.mjs";
+import { t as assert } from "../assert-OguE97r2.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
+import { t as KvKeyCache } from "../keycache-BYMd8q7F.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/keycache.test.ts

package/dist/federation/kv.test.mjs

@@ -1,9 +1,9 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-BTEgfoJo.mjs";
-import { t as MemoryKvStore } from "../kv-QHE0oeM3.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/kv.test.ts
 test("MemoryKvStore", async (t) => {

package/dist/federation/metrics.test.mjs

@@ -1,10 +1,12 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
-import "../std__assert-BTEgfoJo.mjs";
-import { c as recordOutboxActivity, l as recordOutboxEnqueue, o as recordFanoutRecipients, s as recordInboxActivity } from "../metrics-C4attqv0.mjs";
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { t as assertRejects } from "../assert_rejects-DN60FHPX.mjs";
+import { a as instrumentDocumentLoader, c as recordDocumentCache, d as recordInboxActivity, f as recordKeyLookup, l as recordDocumentFetch, m as recordOutboxEnqueue, p as recordOutboxActivity, t as classifyFetchError, u as recordFanoutRecipients } from "../metrics-iRBg8jTk.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
+import { FetchError } from "@fedify/vocab-runtime";
 //#region src/federation/metrics.test.ts
 const noopQueue = {
 	enqueue() {
@@ -103,5 +105,231 @@ test("recordOutboxActivity() records counter with result and activity type", ()
 		"abandoned"
 	]);
 });
+test("recordKeyLookup() records counter and duration with all attributes", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordKeyLookup(meterProvider, {
+		durationMs: 42,
+		result: "fetched",
+		remoteUrl: new URL("https://example.com/users/alice#main-key"),
+		cacheEnabled: true,
+		statusCode: 200
+	});
+	const counters = recorder.getMeasurements("activitypub.key.lookup");
+	assertEquals(counters.length, 1);
+	assertEquals(counters[0].type, "counter");
+	assertEquals(counters[0].value, 1);
+	assertEquals(counters[0].attributes["activitypub.lookup.kind"], "public_key");
+	assertEquals(counters[0].attributes["activitypub.lookup.result"], "fetched");
+	assertEquals(counters[0].attributes["activitypub.remote.host"], "example.com");
+	assertEquals(counters[0].attributes["activitypub.cache.enabled"], true);
+	assertEquals(counters[0].attributes["http.response.status_code"], 200);
+	const durations = recorder.getMeasurements("activitypub.key.lookup.duration");
+	assertEquals(durations.length, 1);
+	assertEquals(durations[0].type, "histogram");
+	assertEquals(durations[0].value, 42);
+	assertEquals(durations[0].attributes["activitypub.lookup.kind"], "public_key");
+	assertEquals(durations[0].attributes["activitypub.lookup.result"], "fetched");
+	assertEquals(durations[0].attributes["activitypub.remote.host"], "example.com");
+	assertEquals(durations[0].attributes["activitypub.cache.enabled"], true);
+	assertEquals(durations[0].attributes["http.response.status_code"], 200);
+});
+test("recordKeyLookup() omits optional attributes when not provided", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordKeyLookup(meterProvider, {
+		durationMs: 0,
+		result: "error",
+		cacheEnabled: false
+	});
+	const counter = recorder.getMeasurement("activitypub.key.lookup");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "error");
+	assertEquals(counter?.attributes["activitypub.cache.enabled"], false);
+	assertEquals("activitypub.remote.host" in counter.attributes, false);
+	assertEquals("http.response.status_code" in counter.attributes, false);
+	const duration = recorder.getMeasurement("activitypub.key.lookup.duration");
+	assertEquals("activitypub.remote.host" in duration.attributes, false);
+	assertEquals("http.response.status_code" in duration.attributes, false);
+});
+test("recordDocumentFetch() records counter and duration with all attributes", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordDocumentFetch(meterProvider, {
+		durationMs: 123,
+		kind: "object",
+		result: "not_found",
+		remoteUrl: new URL("https://remote.test/objects/123"),
+		cacheEnabled: true,
+		statusCode: 404
+	});
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.type, "counter");
+	assertEquals(counter?.value, 1);
+	assertEquals(counter?.attributes["activitypub.lookup.kind"], "object");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "not_found");
+	assertEquals(counter?.attributes["activitypub.remote.host"], "remote.test");
+	assertEquals(counter?.attributes["activitypub.cache.enabled"], true);
+	assertEquals(counter?.attributes["http.response.status_code"], 404);
+	const duration = recorder.getMeasurement("activitypub.document.fetch.duration");
+	assertEquals(duration?.type, "histogram");
+	assertEquals(duration?.value, 123);
+	assertEquals(duration?.attributes["activitypub.lookup.kind"], "object");
+	assertEquals(duration?.attributes["activitypub.lookup.result"], "not_found");
+});
+test("recordDocumentFetch() omits optional attributes when not provided", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordDocumentFetch(meterProvider, {
+		durationMs: 5,
+		kind: "context",
+		result: "fetched"
+	});
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.attributes["activitypub.lookup.kind"], "context");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "fetched");
+	assertEquals("activitypub.remote.host" in counter.attributes, false);
+	assertEquals("activitypub.cache.enabled" in counter.attributes, false);
+	assertEquals("http.response.status_code" in counter.attributes, false);
+	assertEquals(recorder.getMeasurement("activitypub.document.fetch.duration")?.value, 5);
+});
+test("recordDocumentCache() records hit and miss as a counter", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordDocumentCache(meterProvider, {
+		kind: "object",
+		result: "hit",
+		remoteUrl: new URL("https://remote.test/objects/1")
+	});
+	recordDocumentCache(meterProvider, {
+		kind: "context",
+		result: "miss",
+		remoteUrl: new URL("https://w3id.org/security/v1")
+	});
+	const measurements = recorder.getMeasurements("activitypub.document.cache");
+	assertEquals(measurements.length, 2);
+	for (const m of measurements) {
+		assertEquals(m.type, "counter");
+		assertEquals(m.value, 1);
+	}
+	assertEquals(measurements[0].attributes["activitypub.lookup.kind"], "object");
+	assertEquals(measurements[0].attributes["activitypub.lookup.result"], "hit");
+	assertEquals(measurements[0].attributes["activitypub.remote.host"], "remote.test");
+	assertEquals(measurements[1].attributes["activitypub.lookup.kind"], "context");
+	assertEquals(measurements[1].attributes["activitypub.lookup.result"], "miss");
+	assertEquals(measurements[1].attributes["activitypub.remote.host"], "w3id.org");
+});
+test("classifyFetchError() classifies FetchError with 404 as not_found", () => {
+	assertEquals(classifyFetchError(new FetchError("https://example.com/k", "not found", new Response("", { status: 404 }))), {
+		result: "not_found",
+		statusCode: 404
+	});
+});
+test("classifyFetchError() classifies FetchError with 410 as not_found", () => {
+	assertEquals(classifyFetchError(new FetchError("https://example.com/k", "gone", new Response("", { status: 410 }))), {
+		result: "not_found",
+		statusCode: 410
+	});
+});
+test("classifyFetchError() classifies FetchError with 500 as error", () => {
+	assertEquals(classifyFetchError(new FetchError("https://example.com/k", "server error", new Response("", { status: 500 }))), {
+		result: "error",
+		statusCode: 500
+	});
+});
+test("classifyFetchError() classifies FetchError without response as network_error", () => {
+	assertEquals(classifyFetchError(new FetchError("https://example.com/k", "boom")), { result: "network_error" });
+});
+test("classifyFetchError() classifies a bare TypeError as network_error", () => {
+	assertEquals(classifyFetchError(/* @__PURE__ */ new TypeError("connect failed")), { result: "network_error" });
+});
+test("classifyFetchError() classifies an AbortError as network_error", () => {
+	const abort = /* @__PURE__ */ new Error("aborted");
+	abort.name = "AbortError";
+	assertEquals(classifyFetchError(abort), { result: "network_error" });
+});
+test("classifyFetchError() classifies any other thrown value as error", () => {
+	assertEquals(classifyFetchError(/* @__PURE__ */ new Error("nope")), { result: "error" });
+	assertEquals(classifyFetchError("string error"), { result: "error" });
+	assertEquals(classifyFetchError(void 0), { result: "error" });
+});
+test("instrumentDocumentLoader() records fetched on success", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	const inner = (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: { ok: true }
+	});
+	assertEquals((await instrumentDocumentLoader(inner, {
+		meterProvider,
+		kind: "object",
+		cacheEnabled: true
+	})("https://example.com/o")).document, { ok: true });
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.attributes["activitypub.lookup.kind"], "object");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "fetched");
+	assertEquals(counter?.attributes["activitypub.remote.host"], "example.com");
+	assertEquals(counter?.attributes["activitypub.cache.enabled"], true);
+	assertEquals("http.response.status_code" in counter.attributes, false);
+	const duration = recorder.getMeasurement("activitypub.document.fetch.duration");
+	assertEquals(duration?.type, "histogram");
+	assertEquals(duration?.attributes["activitypub.lookup.result"], "fetched");
+});
+test("instrumentDocumentLoader() records not_found on FetchError 404", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	const inner = (url) => Promise.reject(new FetchError(url, "HTTP 404", new Response("", { status: 404 })));
+	const wrapped = instrumentDocumentLoader(inner, {
+		meterProvider,
+		kind: "context",
+		cacheEnabled: false
+	});
+	await assertRejects(() => wrapped("https://example.com/missing"), FetchError);
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.attributes["activitypub.lookup.kind"], "context");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "not_found");
+	assertEquals(counter?.attributes["activitypub.remote.host"], "example.com");
+	assertEquals(counter?.attributes["activitypub.cache.enabled"], false);
+	assertEquals(counter?.attributes["http.response.status_code"], 404);
+});
+test("instrumentDocumentLoader() records network_error on TypeError", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	const inner = () => Promise.reject(/* @__PURE__ */ new TypeError("fetch failed"));
+	const wrapped = instrumentDocumentLoader(inner, {
+		meterProvider,
+		kind: "object"
+	});
+	await assertRejects(() => wrapped("https://example.com/o"), TypeError);
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "network_error");
+	assertEquals("activitypub.cache.enabled" in counter.attributes, false);
+});
+test("instrumentDocumentLoader() returns inner loader unchanged when meterProvider is omitted", async () => {
+	const [, recorder] = createTestMeterProvider();
+	let callCount = 0;
+	const inner = (url) => {
+		callCount++;
+		return Promise.resolve({
+			contextUrl: null,
+			documentUrl: url,
+			document: { ok: true }
+		});
+	};
+	const wrapped = instrumentDocumentLoader(inner, { kind: "object" });
+	assertEquals(wrapped, inner);
+	await wrapped("https://example.com/o");
+	assertEquals(callCount, 1);
+	assertEquals(recorder.getMeasurements("activitypub.document.fetch").length, 0);
+	assertEquals(recorder.getMeasurements("activitypub.document.fetch.duration").length, 0);
+});
+test("instrumentDocumentLoader() omits remote.host when URL is unparseable", async () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	const inner = (url) => Promise.resolve({
+		contextUrl: null,
+		documentUrl: url,
+		document: {}
+	});
+	await instrumentDocumentLoader(inner, {
+		meterProvider,
+		kind: "other"
+	})("not a url");
+	const counter = recorder.getMeasurement("activitypub.document.fetch");
+	assertEquals(counter?.attributes["activitypub.lookup.kind"], "other");
+	assertEquals(counter?.attributes["activitypub.lookup.result"], "fetched");
+	assertEquals("activitypub.remote.host" in counter.attributes, false);
+});
 //#endregion
 export {};