@fedify/fedify 2.3.0-dev.1184 → 2.3.0-dev.1190

package/dist/federation/circuit-breaker.test.mjs

@@ -0,0 +1,446 @@
+import { Temporal } from "@js-temporal/polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as assertEquals } from "../assert_equals-C-ZRDbaf.mjs";
+import "../std__assert-BBjXFNOb.mjs";
+import { t as assertThrows } from "../assert_throws-BOkhLGYc.mjs";
+import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
+import { n as normalizeCircuitBreakerOptions, r as parseCircuitBreakerKvState, t as CircuitBreaker } from "../circuit-breaker-CSWsyoef.mjs";
+import { test } from "@fedify/fixture";
+//#region src/federation/circuit-breaker.test.ts
+var AlwaysConflictingKvStore = class extends MemoryKvStore {
+	attempts = 0;
+	cas(_key, _expectedValue, _newValue, _options) {
+		this.attempts++;
+		if (this.attempts > 10) throw new Error("beforeSend did not stop retrying CAS misses");
+		return Promise.resolve(false);
+	}
+};
+var CountingCasKvStore = class extends MemoryKvStore {
+	attempts = 0;
+	cas(key, expectedValue, newValue, options) {
+		this.attempts++;
+		return super.cas(key, expectedValue, newValue, options);
+	}
+};
+test("normalizeCircuitBreakerOptions() uses numeric failure policy", () => {
+	const options = normalizeCircuitBreakerOptions({
+		failureThreshold: 3,
+		failureWindow: { minutes: 10 }
+	});
+	const failures = [
+		Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		Temporal.Instant.from("2026-05-25T00:05:00Z"),
+		Temporal.Instant.from("2026-05-25T00:10:00Z")
+	];
+	assertEquals(options.failure(failures.slice(0, 2)), false);
+	assertEquals(options.failure(failures), true);
+	assertEquals(options.failure([
+		Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		Temporal.Instant.from("2026-05-25T00:11:00Z"),
+		Temporal.Instant.from("2026-05-25T00:12:00Z")
+	]), false);
+	assertEquals(options.pruneFailures([
+		Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		Temporal.Instant.from("2026-05-25T00:09:00Z"),
+		Temporal.Instant.from("2026-05-25T00:10:00Z"),
+		Temporal.Instant.from("2026-05-25T00:11:00Z"),
+		Temporal.Instant.from("2026-05-25T00:12:00Z")
+	], Temporal.Instant.from("2026-05-25T00:12:00Z")).map((t) => t.toString()), [
+		"2026-05-25T00:10:00Z",
+		"2026-05-25T00:11:00Z",
+		"2026-05-25T00:12:00Z"
+	]);
+});
+test("normalizeCircuitBreakerOptions() validates numeric failure policy", () => {
+	assertThrows(() => normalizeCircuitBreakerOptions({ failureThreshold: 0 }), TypeError, "failureThreshold");
+	assertThrows(() => normalizeCircuitBreakerOptions({ failureThreshold: 1.5 }), TypeError, "failureThreshold");
+});
+test("normalizeCircuitBreakerOptions() truncates sub-millisecond durations", () => {
+	assertEquals(normalizeCircuitBreakerOptions({ recoveryDelay: {
+		milliseconds: 1,
+		nanoseconds: 5e5
+	} }).recoveryDelay, Temporal.Duration.from({ milliseconds: 1 }));
+});
+test("normalizeCircuitBreakerOptions() validates positive durations", () => {
+	assertThrows(() => normalizeCircuitBreakerOptions({ recoveryDelay: { seconds: 0 } }), RangeError, "recoveryDelay");
+	assertThrows(() => normalizeCircuitBreakerOptions({ heldActivityTtl: { seconds: 0 } }), RangeError, "heldActivityTtl");
+	assertThrows(() => normalizeCircuitBreakerOptions({ failureWindow: { seconds: 0 } }), RangeError, "failureWindow");
+	assertThrows(() => normalizeCircuitBreakerOptions({ releaseInterval: { seconds: 0 } }), RangeError, "releaseInterval");
+	assertThrows(() => normalizeCircuitBreakerOptions({ releaseInterval: { nanoseconds: 5e5 } }), RangeError, "releaseInterval");
+});
+test("normalizeCircuitBreakerOptions() accepts callback failure policy", () => {
+	const options = normalizeCircuitBreakerOptions({ failure: (timestamps) => timestamps.length >= 2 });
+	const base = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const failures = Array.from({ length: 105 }, (_, i) => base.add({ minutes: i }));
+	assertEquals(options.failure([Temporal.Instant.from("2026-05-25T00:00:00Z")]), false);
+	assertEquals(options.failure([Temporal.Instant.from("2026-05-25T00:00:00Z"), Temporal.Instant.from("2026-05-25T00:01:00Z")]), true);
+	assertEquals(options.pruneFailures(failures, base.add({ minutes: 105 })).map((t) => t.toString()), failures.slice(-100).map((t) => t.toString()));
+});
+test("parseCircuitBreakerKvState() validates stored shape", () => {
+	assertEquals(parseCircuitBreakerKvState({
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z",
+		halfOpened: "2026-05-25T00:00:00Z"
+	}), {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z",
+		halfOpened: "2026-05-25T00:00:00Z"
+	});
+	assertEquals(parseCircuitBreakerKvState({ state: "open" }), void 0);
+	assertEquals(parseCircuitBreakerKvState({
+		state: "other",
+		failures: []
+	}), void 0);
+	assertEquals(parseCircuitBreakerKvState({
+		state: "open",
+		failures: [],
+		opened: 1
+	}), void 0);
+	assertEquals(parseCircuitBreakerKvState({
+		state: "open",
+		failures: ["not an instant"]
+	}), void 0);
+	assertEquals(parseCircuitBreakerKvState({
+		state: "open",
+		failures: [],
+		halfOpened: "not an instant"
+	}), void 0);
+});
+test("CircuitBreaker opens, probes, closes, and drops held activities", async () => {
+	const kv = new MemoryKvStore();
+	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const transitions = [];
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			failureThreshold: 2,
+			failureWindow: { minutes: 10 },
+			recoveryDelay: { minutes: 30 },
+			heldActivityTtl: { days: 7 },
+			onStateChange(host, previousState, newState) {
+				transitions.push(`${host}:${previousState}->${newState}`);
+			}
+		}
+	});
+	await circuit.recordFailure("remote.example");
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	now = Temporal.Instant.from("2026-05-25T00:05:00Z");
+	await circuit.recordFailure("remote.example");
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z", "2026-05-25T00:05:00Z"],
+		opened: "2026-05-25T00:05:00Z"
+	});
+	assertEquals(transitions, ["remote.example:closed->open"]);
+	let decision = await circuit.beforeSend("remote.example", {});
+	assertEquals(decision, {
+		type: "hold",
+		delay: Temporal.Duration.from({ minutes: 30 }),
+		heldSince: now,
+		state: "open"
+	});
+	now = Temporal.Instant.from("2026-05-25T00:35:00Z");
+	decision = await circuit.beforeSend("remote.example", {});
+	assertEquals(decision, {
+		type: "send",
+		probe: true,
+		stateChange: {
+			previousState: "open",
+			newState: "half-open"
+		}
+	});
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "half-open",
+		failures: ["2026-05-25T00:00:00Z", "2026-05-25T00:05:00Z"],
+		opened: "2026-05-25T00:05:00Z",
+		halfOpened: "2026-05-25T00:35:00Z"
+	});
+	await circuit.recordSuccess("remote.example");
+	assertEquals(await circuit.getState("remote.example"), void 0);
+	assertEquals(transitions, [
+		"remote.example:closed->open",
+		"remote.example:open->half-open",
+		"remote.example:half-open->closed"
+	]);
+	decision = await circuit.beforeSend("remote.example", { circuitHeldSince: "2026-05-17T00:00:00Z" });
+	assertEquals(decision, {
+		type: "drop",
+		heldSince: Temporal.Instant.from("2026-05-17T00:00:00Z")
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"remote.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z", "2026-05-25T00:05:00Z"],
+		opened: "2026-05-25T00:05:00Z"
+	});
+	decision = await circuit.beforeSend("remote.example", { circuitHeldSince: "2026-05-17T00:00:00Z" });
+	assertEquals(decision, {
+		type: "drop",
+		heldSince: Temporal.Instant.from("2026-05-17T00:00:00Z")
+	});
+});
+test("CircuitBreaker recovers stale half-open probes", async () => {
+	const kv = new MemoryKvStore();
+	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			recoveryDelay: { seconds: 30 },
+			releaseInterval: { seconds: 5 }
+		}
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"remote.example"
+	], {
+		state: "half-open",
+		failures: ["2026-05-24T23:00:00Z"],
+		opened: "2026-05-24T23:00:00Z",
+		halfOpened: "2026-05-24T23:59:54Z"
+	});
+	let decision = await circuit.beforeSend("remote.example", {});
+	assertEquals(decision, {
+		type: "hold",
+		state: "half-open",
+		delay: Temporal.Duration.from({ seconds: 5 }),
+		heldSince: now
+	});
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "half-open",
+		failures: ["2026-05-24T23:00:00Z"],
+		opened: "2026-05-24T23:00:00Z",
+		halfOpened: "2026-05-24T23:59:54Z"
+	});
+	now = Temporal.Instant.from("2026-05-25T00:00:30Z");
+	decision = await circuit.beforeSend("remote.example", {});
+	assertEquals(decision, {
+		type: "send",
+		probe: true
+	});
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "half-open",
+		failures: ["2026-05-24T23:00:00Z"],
+		opened: "2026-05-24T23:00:00Z",
+		halfOpened: "2026-05-25T00:00:30Z"
+	});
+});
+test("CircuitBreaker caps held delays at activity TTL", async () => {
+	const kv = new MemoryKvStore();
+	const now = Temporal.Instant.from("2026-05-25T00:05:00Z");
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			recoveryDelay: { minutes: 30 },
+			heldActivityTtl: { minutes: 10 },
+			releaseInterval: { minutes: 10 }
+		}
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"new-open.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	let decision = await circuit.beforeSend("new-open.example", {});
+	assertEquals(decision.type, "hold");
+	if (decision.type === "hold") {
+		assertEquals(decision.state, "open");
+		assertEquals(decision.delay.total({ unit: "minute" }), 10);
+		assertEquals(decision.heldSince.toString(), "2026-05-25T00:05:00Z");
+	}
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"open.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	decision = await circuit.beforeSend("open.example", { circuitHeldSince: "2026-05-25T00:00:00Z" });
+	assertEquals(decision.type, "hold");
+	if (decision.type === "hold") {
+		assertEquals(decision.state, "open");
+		assertEquals(decision.delay.total({ unit: "minute" }), 5);
+		assertEquals(decision.heldSince.toString(), "2026-05-25T00:00:00Z");
+	}
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"half-open.example"
+	], {
+		state: "half-open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z",
+		halfOpened: "2026-05-25T00:00:00Z"
+	});
+	decision = await circuit.beforeSend("half-open.example", { circuitHeldSince: "2026-05-25T00:00:00Z" });
+	assertEquals(decision.type, "hold");
+	if (decision.type === "hold") {
+		assertEquals(decision.state, "half-open");
+		assertEquals(decision.delay.total({ unit: "minute" }), 5);
+		assertEquals(decision.heldSince.toString(), "2026-05-25T00:00:00Z");
+	}
+});
+test("CircuitBreaker ignores malformed held timestamps", async () => {
+	const kv = new MemoryKvStore();
+	const now = Temporal.Instant.from("2026-05-25T00:05:00Z");
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: { recoveryDelay: { minutes: 30 } }
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"malformed-held.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	assertEquals(await circuit.beforeSend("malformed-held.example", { circuitHeldSince: "not an instant" }), {
+		type: "hold",
+		state: "open",
+		delay: Temporal.Duration.from({ minutes: 25 }),
+		heldSince: now
+	});
+});
+test("CircuitBreaker bounds beforeSend CAS retries", async () => {
+	let kv = new AlwaysConflictingKvStore();
+	const now = Temporal.Instant.from("2026-05-25T00:30:00Z");
+	let circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			recoveryDelay: { minutes: 30 },
+			releaseInterval: { seconds: 5 }
+		}
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"open.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	let decision = await circuit.beforeSend("open.example", {});
+	assertEquals(kv.attempts, 10);
+	assertEquals(decision, {
+		type: "hold",
+		state: "open",
+		delay: Temporal.Duration.from({ seconds: 5 }),
+		heldSince: now
+	});
+	kv = new AlwaysConflictingKvStore();
+	circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			recoveryDelay: { minutes: 30 },
+			releaseInterval: { seconds: 5 }
+		}
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"half-open.example"
+	], {
+		state: "half-open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z",
+		halfOpened: "2026-05-25T00:00:00Z"
+	});
+	decision = await circuit.beforeSend("half-open.example", {});
+	assertEquals(kv.attempts, 10);
+	assertEquals(decision, {
+		type: "hold",
+		state: "half-open",
+		delay: Temporal.Duration.from({ seconds: 5 }),
+		heldSince: now
+	});
+});
+test("CircuitBreaker skips recording failures for open circuits", async () => {
+	const kv = new CountingCasKvStore();
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:01:00Z")
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"open.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	assertEquals(await circuit.recordFailure("open.example"), void 0);
+	assertEquals(kv.attempts, 0);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"open.example"
+	]), {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+});
+test("CircuitBreaker prunes stale closed failure history", async () => {
+	const kv = new MemoryKvStore();
+	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: {
+			failureThreshold: 2,
+			failureWindow: { minutes: 10 }
+		}
+	});
+	await circuit.recordFailure("sporadic.example");
+	assertEquals(await circuit.getState("sporadic.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	now = Temporal.Instant.from("2026-05-25T00:20:00Z");
+	await circuit.recordFailure("sporadic.example");
+	assertEquals(await circuit.getState("sporadic.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:20:00Z"]
+	});
+	now = Temporal.Instant.from("2026-05-25T00:40:00Z");
+	await circuit.recordFailure("sporadic.example");
+	assertEquals(await circuit.getState("sporadic.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:40:00Z"]
+	});
+});
+//#endregion
+export {};

package/dist/federation/collection.test.mjs

@@ -3,7 +3,7 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 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 { n as digest, t as buildCollectionSynchronizationHeader } from "../collection-Cc3DVAhE.mjs";
 import { test } from "@fedify/fixture";
 import { decodeHex } from "byte-encodings/hex";
 //#region src/federation/collection.test.ts

package/dist/federation/handler.test.mjs

@@ -8,11 +8,11 @@ import { n as assertGreaterOrEqual, t as assertRejects } from "../assert_rejects
 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-CevxpgFA.mjs";
+import { s as signRequest } from "../http-CSwCAQ-H.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, s as rsaPublicKey2 } from "../keys-C3kae-6B.mjs";
-import { a as compactJsonLd, p as signJsonLd } from "../ld-DbTiidUm.mjs";
+import { a as compactJsonLd, p as signJsonLd } from "../ld-BdcT_irA.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-WclBYQsJ.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-BUGT2LmO.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";

package/dist/federation/idempotency.test.mjs

@@ -4,9 +4,9 @@ globalThis.addEventListener = () => {};
 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-AVmt2hSm.mjs";
+import { r as signObject } from "../proof-CzqluPMh.mjs";
 import { t as MemoryKvStore } from "../kv-x2IvBUyq.mjs";
-import { o as createFederation } from "../middleware-WclBYQsJ.mjs";
+import { o as createFederation } from "../middleware-BUGT2LmO.mjs";
 import { Create, Follow, Person } from "@fedify/vocab";
 import { mockDocumentLoader, test } from "@fedify/fixture";
 //#region src/federation/idempotency.test.ts

package/dist/federation/keycache.test.mjs

@@ -5,7 +5,7 @@ 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 { t as KvKeyCache } from "../keycache-BeU0LCII.mjs";
 import { CryptographicKey, Multikey } from "@fedify/vocab";
 import { test } from "@fedify/fixture";
 //#region src/federation/keycache.test.ts

package/dist/federation/metrics.test.mjs

@@ -4,7 +4,7 @@ globalThis.addEventListener = () => {};
 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 { _ as recordOutboxActivity, a as instrumentDocumentLoader, c as recordCollectionDispatchDuration, d as recordCollectionTotalItems, f as recordDocumentCache, g as recordKeyLookup, h as recordInboxActivity, l as recordCollectionPageItems, m as recordFanoutRecipients, p as recordDocumentFetch, t as classifyFetchError, u as recordCollectionRequest, v as recordOutboxEnqueue, y as recordWebFingerHandle } from "../metrics-CE6rG2kw.mjs";
+import { _ as recordKeyLookup, a as instrumentDocumentLoader, b as recordWebFingerHandle, c as recordCircuitBreakerStateChange, d as recordCollectionRequest, f as recordCollectionTotalItems, g as recordInboxActivity, h as recordFanoutRecipients, i as getRemoteHost, l as recordCollectionDispatchDuration, m as recordDocumentFetch, p as recordDocumentCache, t as classifyFetchError, u as recordCollectionPageItems, v as recordOutboxActivity, y as recordOutboxEnqueue } from "../metrics-Ci97wkob.mjs";
 import { createTestMeterProvider, test } from "@fedify/fixture";
 import { FetchError } from "@fedify/vocab-runtime";
 //#region src/federation/metrics.test.ts
@@ -16,6 +16,11 @@ const noopQueue = {
 		return Promise.resolve();
 	}
 };
+test("getRemoteHost() includes non-default ports", () => {
+	assertEquals(getRemoteHost(new URL("https://example.com/inbox")), "example.com");
+	assertEquals(getRemoteHost(new URL("https://example.com:8443/inbox")), "example.com:8443");
+	assertEquals(getRemoteHost(new URL("https://example.com:443/inbox")), "example.com");
+});
 test("recordFanoutRecipients() records the recipient count with activity type", () => {
 	const [meterProvider, recorder] = createTestMeterProvider();
 	recordFanoutRecipients(meterProvider, 7, "https://www.w3.org/ns/activitystreams#Create");
@@ -105,6 +110,16 @@ test("recordOutboxActivity() records counter with result and activity type", ()
 		"abandoned"
 	]);
 });
+test("recordCircuitBreakerStateChange() records counter with bounded attributes", () => {
+	const [meterProvider, recorder] = createTestMeterProvider();
+	recordCircuitBreakerStateChange(meterProvider, "remote.example", "half_open");
+	const measurements = recorder.getMeasurements("activitypub.circuit_breaker.state_change");
+	assertEquals(measurements.length, 1);
+	assertEquals(measurements[0].type, "counter");
+	assertEquals(measurements[0].value, 1);
+	assertEquals(measurements[0].attributes["activitypub.remote.host"], "remote.example");
+	assertEquals(measurements[0].attributes["activitypub.circuit_breaker.state"], "half_open");
+});
 test("recordKeyLookup() records counter and duration with all attributes", () => {
 	const [meterProvider, recorder] = createTestMeterProvider();
 	recordKeyLookup(meterProvider, {