@fedify/fedify 2.3.1 → 2.3.2-dev.1556

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

@@ -5,7 +5,8 @@ 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-rV3vodCc.mjs";
-import { n as normalizeCircuitBreakerOptions, r as parseCircuitBreakerKvState, t as CircuitBreaker } from "../circuit-breaker-CSWsyoef.mjs";
+import { n as normalizeCircuitBreakerOptions, r as parseCircuitBreakerKvState, t as CircuitBreaker } from "../circuit-breaker-DLS_n1x5.mjs";
+import { t as markCircuitBreakerLegacySweepDone } from "../circuit-breaker-test-utils-BVnv3T76.mjs";
 import { test } from "@fedify/fixture";
 //#region src/federation/circuit-breaker.test.ts
 var AlwaysConflictingKvStore = class extends MemoryKvStore {
@@ -18,15 +19,109 @@ var AlwaysConflictingKvStore = class extends MemoryKvStore {
 };
 var CountingCasKvStore = class extends MemoryKvStore {
 	attempts = 0;
+	options = [];
 	cas(key, expectedValue, newValue, options) {
 		this.attempts++;
+		this.options.push(options);
 		return super.cas(key, expectedValue, newValue, options);
 	}
 };
+var CountingSetKvStore = class {
+	#store = new MemoryKvStore();
+	keys = [];
+	options = [];
+	get(key) {
+		return this.#store.get(key);
+	}
+	set(key, value, options) {
+		this.keys.push(key);
+		this.options.push(options);
+		return this.#store.set(key, value, options);
+	}
+	delete(key) {
+		return this.#store.delete(key);
+	}
+	list(prefix) {
+		return this.#store.list(prefix);
+	}
+};
+var CountingSweepKvStore = class extends MemoryKvStore {
+	listCalls = 0;
+	markerGetCalls = 0;
+	casCalls = [];
+	deletedKeys = [];
+	get(key) {
+		if (key.length === 4 && key[0] === "_fedify" && key[1] === "circuit" && key[2] === "__fedify_meta" && key[3] === "circuit_breaker_state_ttl_sweep_v1") this.markerGetCalls++;
+		return super.get(key);
+	}
+	cas(key, expectedValue, newValue, options) {
+		this.casCalls.push({
+			key,
+			options
+		});
+		return super.cas(key, expectedValue, newValue, options);
+	}
+	async *list(prefix) {
+		this.listCalls++;
+		yield* super.list(prefix);
+	}
+	delete(key) {
+		this.deletedKeys.push(key);
+		return super.delete(key);
+	}
+};
+var ConflictingSweepMarkerKvStore = class extends CountingSweepKvStore {
+	attempts = 0;
+	cas(key, expectedValue, newValue, options) {
+		if (key.length === 4 && key[0] === "_fedify" && key[1] === "circuit" && key[2] === "__fedify_meta" && key[3] === "circuit_breaker_state_ttl_sweep_v1") {
+			this.attempts++;
+			if (this.attempts > 3) throw new Error("legacy sweep did not stop retrying CAS misses");
+			return Promise.resolve(false);
+		}
+		return super.cas(key, expectedValue, newValue, options);
+	}
+};
+var MarkerChangedDuringListKvStore = class extends CountingSweepKvStore {
+	async *list(prefix) {
+		yield* super.list(prefix);
+		await super.set([
+			"_fedify",
+			"circuit",
+			"__fedify_meta",
+			"circuit_breaker_state_ttl_sweep_v1"
+		], { state: "final" });
+	}
+};
+var UpdatingDuringListKvStore = class extends MemoryKvStore {
+	async *list(prefix) {
+		for await (const entry of super.list(prefix)) {
+			if (entry.key.length === 3 && entry.key[0] === "_fedify" && entry.key[1] === "circuit" && entry.key[2] === "racy.example") await super.set(entry.key, {
+				state: "closed",
+				failures: ["2026-05-25T00:01:00Z"]
+			});
+			yield entry;
+		}
+	}
+};
+var FailingOnceSweepKvStore = class extends MemoryKvStore {
+	listCalls = 0;
+	deletedKeys = [];
+	async *list(prefix) {
+		this.listCalls++;
+		if (this.listCalls === 1) throw new Error("transient list failure");
+		yield* super.list(prefix);
+	}
+	delete(key) {
+		this.deletedKeys.push(key);
+		return super.delete(key);
+	}
+};
 test("normalizeCircuitBreakerOptions() uses numeric failure policy", () => {
 	const options = normalizeCircuitBreakerOptions({
 		failureThreshold: 3,
-		failureWindow: { minutes: 10 }
+		failureWindow: { minutes: 10 },
+		heldActivityTtl: { hours: 1 },
+		recoveryDelay: { hours: 2 }
 	});
 	const failures = [
 		Temporal.Instant.from("2026-05-25T00:00:00Z"),
@@ -51,6 +146,7 @@ test("normalizeCircuitBreakerOptions() uses numeric failure policy", () => {
 		"2026-05-25T00:11:00Z",
 		"2026-05-25T00:12:00Z"
 	]);
+	assertEquals(options.stateTtl, Temporal.Duration.from({ hours: 3 }));
 });
 test("normalizeCircuitBreakerOptions() validates numeric failure policy", () => {
 	assertThrows(() => normalizeCircuitBreakerOptions({ failureThreshold: 0 }), TypeError, "failureThreshold");
@@ -68,6 +164,10 @@ test("normalizeCircuitBreakerOptions() validates positive durations", () => {
 	assertThrows(() => normalizeCircuitBreakerOptions({ failureWindow: { seconds: 0 } }), RangeError, "failureWindow");
 	assertThrows(() => normalizeCircuitBreakerOptions({ releaseInterval: { seconds: 0 } }), RangeError, "releaseInterval");
 	assertThrows(() => normalizeCircuitBreakerOptions({ releaseInterval: { nanoseconds: 5e5 } }), RangeError, "releaseInterval");
+	assertThrows(() => normalizeCircuitBreakerOptions({
+		recoveryDelay: { minutes: 30 },
+		stateTtl: { minutes: 29 }
+	}), RangeError, "stateTtl");
 });
 test("normalizeCircuitBreakerOptions() accepts callback failure policy", () => {
 	const options = normalizeCircuitBreakerOptions({ failure: (timestamps) => timestamps.length >= 2 });
@@ -82,7 +182,8 @@ test("parseCircuitBreakerKvState() validates stored shape", () => {
 		state: "open",
 		failures: ["2026-05-25T00:00:00Z"],
 		opened: "2026-05-25T00:00:00Z",
-		halfOpened: "2026-05-25T00:00:00Z"
+		halfOpened: "2026-05-25T00:00:00Z",
+		__fedifyCircuitBreakerStateVersion: 1
 	}), {
 		state: "open",
 		failures: ["2026-05-25T00:00:00Z"],
@@ -192,6 +293,7 @@ test("CircuitBreaker opens, probes, closes, and drops held activities", async ()
 });
 test("CircuitBreaker recovers stale half-open probes", async () => {
 	const kv = new MemoryKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
 	const circuit = new CircuitBreaker({
 		kv,
@@ -240,6 +342,7 @@ test("CircuitBreaker recovers stale half-open probes", async () => {
 });
 test("CircuitBreaker caps held delays at activity TTL", async () => {
 	const kv = new MemoryKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	const now = Temporal.Instant.from("2026-05-25T00:05:00Z");
 	const circuit = new CircuitBreaker({
 		kv,
@@ -303,6 +406,7 @@ test("CircuitBreaker caps held delays at activity TTL", async () => {
 });
 test("CircuitBreaker ignores malformed held timestamps", async () => {
 	const kv = new MemoryKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	const now = Temporal.Instant.from("2026-05-25T00:05:00Z");
 	const circuit = new CircuitBreaker({
 		kv,
@@ -328,6 +432,7 @@ test("CircuitBreaker ignores malformed held timestamps", async () => {
 });
 test("CircuitBreaker bounds beforeSend CAS retries", async () => {
 	let kv = new AlwaysConflictingKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	const now = Temporal.Instant.from("2026-05-25T00:30:00Z");
 	let circuit = new CircuitBreaker({
 		kv,
@@ -356,6 +461,7 @@ test("CircuitBreaker bounds beforeSend CAS retries", async () => {
 		heldSince: now
 	});
 	kv = new AlwaysConflictingKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	circuit = new CircuitBreaker({
 		kv,
 		prefix: ["_fedify", "circuit"],
@@ -386,6 +492,7 @@ test("CircuitBreaker bounds beforeSend CAS retries", async () => {
 });
 test("CircuitBreaker skips recording failures for open circuits", async () => {
 	const kv = new CountingCasKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
 	const circuit = new CircuitBreaker({
 		kv,
 		prefix: ["_fedify", "circuit"],
@@ -412,6 +519,518 @@ test("CircuitBreaker skips recording failures for open circuits", async () => {
 		opened: "2026-05-25T00:00:00Z"
 	});
 });
+test("CircuitBreaker writes stored states with a TTL", async () => {
+	const kv = new CountingCasKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
+	await new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: {
+			failureThreshold: 2,
+			failureWindow: { hours: 3 },
+			recoveryDelay: { hours: 1 },
+			heldActivityTtl: { days: 2 }
+		}
+	}).recordFailure("remote.example");
+	assertEquals(kv.options.at(-1), { ttl: Temporal.Duration.from({
+		days: 2,
+		hours: 1
+	}) });
+});
+test("CircuitBreaker writes stored states with a TTL without CAS", async () => {
+	const kv = new CountingSetKvStore();
+	await new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: {
+			failureThreshold: 2,
+			failureWindow: { hours: 3 },
+			recoveryDelay: { hours: 1 },
+			heldActivityTtl: { days: 2 }
+		}
+	}).recordFailure("remote.example");
+	assertEquals(kv.keys, [[
+		"_fedify",
+		"circuit",
+		"remote.example"
+	]]);
+	assertEquals(kv.options.at(-1), { ttl: Temporal.Duration.from({
+		days: 2,
+		hours: 1
+	}) });
+});
+test("CircuitBreaker preserves custom failure history by default", async () => {
+	const kv = new CountingCasKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
+	await new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failure: (timestamps) => timestamps.length >= 2 }
+	}).recordFailure("remote.example");
+	assertEquals(kv.options.at(-1), void 0);
+});
+test("CircuitBreaker accepts an explicit TTL with custom failure policies", async () => {
+	const kv = new CountingCasKvStore();
+	await markCircuitBreakerLegacySweepDone(kv);
+	await new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: {
+			failure: (timestamps) => timestamps.length >= 2,
+			stateTtl: { days: 14 }
+		}
+	}).recordFailure("remote.example");
+	assertEquals(kv.options.at(-1), { ttl: Temporal.Duration.from({ days: 14 }) });
+});
+test("CircuitBreaker skips legacy sweep when custom policies have no TTL", async () => {
+	const kv = new CountingSweepKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failure: (timestamps) => timestamps.length >= 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(kv.listCalls, 0);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+});
+test("CircuitBreaker migrates legacy states without TTL once", async () => {
+	const kv = new CountingSweepKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale-a.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale-b.example"
+	], {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z"
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"malformed.example"
+	], "stale");
+	await kv.set([
+		"_fedify",
+		"other",
+		"untouched.example"
+	], "keep");
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"future"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: { failureThreshold: 2 }
+	});
+	assertEquals(await circuit.beforeSend("stale-b.example", {}), {
+		type: "hold",
+		state: "open",
+		delay: Temporal.Duration.from({ minutes: 30 }),
+		heldSince: Temporal.Instant.from("2026-05-25T00:00:00Z")
+	});
+	await circuit.pendingSweep;
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"stale-a.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"],
+		__fedifyCircuitBreakerStateVersion: 1
+	});
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"stale-b.example"
+	]), {
+		state: "open",
+		failures: ["2026-05-25T00:00:00Z"],
+		opened: "2026-05-25T00:00:00Z",
+		__fedifyCircuitBreakerStateVersion: 1
+	});
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"malformed.example"
+	]), void 0);
+	assertEquals(await kv.get([
+		"_fedify",
+		"other",
+		"untouched.example"
+	]), "keep");
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"future"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	await circuit.recordFailure("remote.example");
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	assertEquals(kv.listCalls, 1);
+	assertEquals(kv.casCalls.find(({ key }) => key.length === 3 && key[0] === "_fedify" && key[1] === "circuit" && key[2] === "stale-a.example")?.options, { ttl: Temporal.Duration.from({ days: 7 }) });
+	assertEquals(kv.deletedKeys, [[
+		"_fedify",
+		"circuit",
+		"malformed.example"
+	]]);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), {
+		state: "done",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"late-stale.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	await circuit.recordFailure("another.example");
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"late-stale.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	assertEquals(kv.listCalls, 1);
+	now = Temporal.Instant.from("2026-06-02T00:00:00Z");
+	await circuit.recordFailure("final.example");
+	await circuit.pendingSweep;
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"late-stale.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"],
+		__fedifyCircuitBreakerStateVersion: 1
+	});
+	assertEquals(await circuit.getState("another.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	assertEquals(kv.listCalls, 2);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), { state: "final" });
+});
+test("CircuitBreaker does not sweep state changed after listing", async () => {
+	const kv = new UpdatingDuringListKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"racy.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:02:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"racy.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:01:00Z"]
+	});
+});
+test("CircuitBreaker skips legacy sweep already running elsewhere", async () => {
+	const kv = new CountingSweepKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	], {
+		state: "sweeping",
+		started: "2026-05-25T00:00:00Z",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	assertEquals(kv.listCalls, 0);
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+});
+test("CircuitBreaker does not overwrite a changed legacy sweep marker", async () => {
+	const kv = new MarkerChangedDuringListKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), { state: "final" });
+});
+test("CircuitBreaker bounds legacy sweep CAS retries", async () => {
+	const kv = new ConflictingSweepMarkerKvStore();
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.getState("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(kv.attempts, 3);
+	assertEquals(kv.listCalls, 0);
+});
+test("CircuitBreaker retries expired legacy sweep markers", async () => {
+	const kv = new CountingSweepKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	], {
+		state: "sweeping",
+		started: "2026-05-25T00:00:00Z",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:06:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(kv.listCalls, 1);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"],
+		__fedifyCircuitBreakerStateVersion: 1
+	});
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), {
+		state: "done",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+});
+test("CircuitBreaker caches completed legacy sweep markers", async () => {
+	const doneKv = new CountingSweepKvStore();
+	await doneKv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	], {
+		state: "done",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+	let now = Temporal.Instant.from("2026-05-25T00:00:00Z");
+	const doneCircuit = new CircuitBreaker({
+		kv: doneKv,
+		prefix: ["_fedify", "circuit"],
+		now: () => now,
+		options: { failureThreshold: 2 }
+	});
+	await doneCircuit.recordFailure("remote.example");
+	await doneCircuit.pendingSweep;
+	await doneCircuit.recordFailure("another.example");
+	await doneCircuit.pendingSweep;
+	assertEquals(doneKv.markerGetCalls, 1);
+	now = Temporal.Instant.from("2026-06-02T00:00:00Z");
+	await doneCircuit.recordFailure("final.example");
+	await doneCircuit.pendingSweep;
+	assertEquals(doneKv.markerGetCalls, 2);
+	const finalKv = new CountingSweepKvStore();
+	await markCircuitBreakerLegacySweepDone(finalKv);
+	const finalCircuit = new CircuitBreaker({
+		kv: finalKv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await finalCircuit.recordFailure("remote.example");
+	await finalCircuit.pendingSweep;
+	await finalCircuit.recordFailure("another.example");
+	await finalCircuit.pendingSweep;
+	assertEquals(finalKv.markerGetCalls, 1);
+});
+test("CircuitBreaker retries malformed legacy sweep markers", async () => {
+	const kv = new CountingSweepKvStore();
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	], {
+		state: "done",
+		retryUntil: "not an instant"
+	});
+	await kv.set([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	], {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(kv.listCalls, 1);
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"stale.example"
+	]), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"],
+		__fedifyCircuitBreakerStateVersion: 1
+	});
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), {
+		state: "done",
+		retryUntil: "2026-06-01T00:00:00Z"
+	});
+});
+test("CircuitBreaker retries legacy sweep after transient failures", async () => {
+	const kv = new FailingOnceSweepKvStore();
+	const circuit = new CircuitBreaker({
+		kv,
+		prefix: ["_fedify", "circuit"],
+		now: () => Temporal.Instant.from("2026-05-25T00:00:00Z"),
+		options: { failureThreshold: 2 }
+	});
+	await circuit.recordFailure("remote.example");
+	await circuit.pendingSweep;
+	assertEquals(await kv.get([
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]), void 0);
+	assertEquals(kv.deletedKeys, [[
+		"_fedify",
+		"circuit",
+		"__fedify_meta",
+		"circuit_breaker_state_ttl_sweep_v1"
+	]]);
+	assertEquals(await circuit.getState("remote.example"), {
+		state: "closed",
+		failures: ["2026-05-25T00:00:00Z"]
+	});
+	await circuit.recordFailure("another.example");
+	await circuit.pendingSweep;
+	assertEquals(kv.listCalls, 2);
+	assertEquals(await circuit.getState("another.example"), {
+		state: "closed",
+		failures: ["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");