@fedify/vocab 2.4.0-pr.936.41 → 2.4.1

package/dist-tests/actor-D_QaCMro.mjs

@@ -0,0 +1,276 @@
+import "temporal-polyfill";
+globalThis.addEventListener = () => {};
+import { F as Person, P as Organization, U as Service, a as Application, b as Group } from "./vocab-DaniQwU7.mjs";
+import { t as getTypeId } from "./type-BMdjm4Eg.mjs";
+import { canonicalizePortableUri, formatIri, fromCompatibleEf61Id, isGatewayUrl } from "@fedify/vocab-runtime";
+import { lookupWebFinger } from "@fedify/webfinger";
+import { SpanStatusCode, trace } from "@opentelemetry/api";
+import { domainToASCII, domainToUnicode } from "node:url";
+//#region deno.json
+var name = "@fedify/vocab";
+var version = "2.4.1";
+//#endregion
+//#region src/actor.ts
+const ACTOR_DISCOVERY_HISTOGRAM_BUCKETS = [
+	5,
+	10,
+	25,
+	50,
+	75,
+	100,
+	250,
+	500,
+	750,
+	1e3,
+	2500,
+	5e3,
+	7500,
+	1e4
+];
+const actorDiscoveryInstruments = /* @__PURE__ */ new WeakMap();
+function getActorDiscoveryInstruments(meterProvider) {
+	let instruments = actorDiscoveryInstruments.get(meterProvider);
+	if (instruments == null) {
+		const meter = meterProvider.getMeter(name, version);
+		instruments = {
+			discovery: meter.createCounter("activitypub.actor.discovery", {
+				description: "Actor handle discovery attempts via getActorHandle(), classified by terminal outcome.",
+				unit: "{discovery}"
+			}),
+			discoveryDuration: meter.createHistogram("activitypub.actor.discovery.duration", {
+				description: "Duration of getActorHandle() actor discovery calls.",
+				unit: "ms",
+				advice: { explicitBucketBoundaries: [...ACTOR_DISCOVERY_HISTOGRAM_BUCKETS] }
+			})
+		};
+		actorDiscoveryInstruments.set(meterProvider, instruments);
+	}
+	return instruments;
+}
+function getActorDiscoveryRemoteHost(actor) {
+	const id = actor instanceof URL ? actor : actor.id;
+	if (id == null) return void 0;
+	if (isPortableActorId(id)) return actor instanceof URL ? void 0 : actor.gateway?.host;
+	return id.host === "" ? void 0 : id.host;
+}
+var ActorHandleNotFoundError = class extends TypeError {
+	constructor() {
+		super("Actor does not have enough information to get the handle.");
+		this.name = "ActorHandleNotFoundError";
+	}
+};
+/**
+* Checks if the given object is an {@link Actor}.
+* @param object The object to check.
+* @returns `true` if the given object is an {@link Actor}.
+*/
+function isActor(object) {
+	return object instanceof Application || object instanceof Group || object instanceof Organization || object instanceof Person || object instanceof Service;
+}
+/**
+* Gets the type name of the given actor.
+* @param actor The actor to get the type name of.
+* @returns The type name of the given actor.
+*/
+function getActorTypeName(actor) {
+	if (actor instanceof Application) return "Application";
+	else if (actor instanceof Group) return "Group";
+	else if (actor instanceof Organization) return "Organization";
+	else if (actor instanceof Person) return "Person";
+	else if (actor instanceof Service) return "Service";
+	throw new Error("Unknown actor type.");
+}
+/**
+* Gets the actor class by the given type name.
+* @param typeName The type name to get the actor class by.
+* @returns The actor class by the given type name.
+*/
+function getActorClassByTypeName(typeName) {
+	switch (typeName) {
+		case "Application": return Application;
+		case "Group": return Group;
+		case "Organization": return Organization;
+		case "Person": return Person;
+		case "Service": return Service;
+	}
+	throw new Error("Unknown actor type name.");
+}
+/**
+* Gets the actor handle, of the form `@username@domain`, from the given actor
+* or an actor URI.
+*
+* @example
+* ``` typescript
+* // Get the handle of an actor object:
+* await getActorHandle(
+*   new Person({ id: new URL("https://fosstodon.org/users/hongminhee") })
+* );
+*
+* // Get the handle of an actor URI:
+* await getActorHandle(new URL("https://fosstodon.org/users/hongminhee"));
+* ```
+*
+* For an [FEP-ef61] portable actor, whose ID is an `ap:` or `ap+ef61:` URI,
+* the domain is taken from the first gateway in the actor's `gateways` rather
+* than from its ID.  The handle is returned only if its WebFinger response
+* links back to the actor, since the actor's `gateways` are claimed by the
+* actor itself; a failed WebFinger lookup is not enough information to get
+* the handle.  A portable actor without `gateways` or
+* `preferredUsername`, or a portable actor URI (which does not tell its
+* gateways), is not supported.
+*
+* [FEP-ef61]: https://w3id.org/fep/ef61
+*
+* @param actor The actor or actor URI to get the handle from.
+* @param options The extra options for getting the actor handle.
+* @returns The actor handle.  It starts with `@` and is followed by the
+*          username and domain, separated by `@` by default (it can be
+*          customized with the options).
+* @throws {TypeError} If the actor does not have enough information to get the
+*                     handle.
+* @since 0.4.0
+*/
+async function getActorHandle(actor, options = {}) {
+	return await (options.tracerProvider ?? trace.getTracerProvider()).getTracer(name, version).startActiveSpan("activitypub.get_actor_handle", async (span) => {
+		if (isActor(actor)) {
+			if (actor.id != null) span.setAttribute("activitypub.actor.id", actor.id.href);
+			span.setAttribute("activitypub.actor.type", getTypeId(actor).href);
+		}
+		const meterProvider = options.meterProvider;
+		const start = meterProvider == null ? 0 : performance.now();
+		let result = "error";
+		try {
+			const handle = await getActorHandleInternal(actor, options);
+			result = "resolved";
+			return handle;
+		} catch (error) {
+			result = error instanceof ActorHandleNotFoundError ? "not_found" : "error";
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: String(error)
+			});
+			throw error;
+		} finally {
+			if (meterProvider != null) {
+				const attributes = { "activitypub.actor.discovery.result": result };
+				const host = getActorDiscoveryRemoteHost(actor);
+				if (host != null) attributes["activitypub.remote.host"] = host;
+				const instruments = getActorDiscoveryInstruments(meterProvider);
+				instruments.discovery.add(1, attributes);
+				instruments.discoveryDuration.record(Math.max(0, performance.now() - start), attributes);
+			}
+			span.end();
+		}
+	});
+}
+async function getActorHandleInternal(actor, options = {}) {
+	const actorId = actor instanceof URL ? actor : actor.id;
+	if (actorId != null && isPortableActorId(actorId)) {
+		if (actor instanceof URL) throw new ActorHandleNotFoundError();
+		return await getPortableActorHandle(actor, actorId, options);
+	}
+	if (actorId != null) {
+		const result = await lookupWebFinger(actorId, {
+			userAgent: options.userAgent,
+			tracerProvider: options.tracerProvider,
+			meterProvider: options.meterProvider
+		});
+		if (result != null) {
+			const aliases = [...result.aliases ?? []];
+			if (result.subject != null) aliases.unshift(result.subject);
+			for (const alias of aliases) {
+				const match = alias.match(/^acct:([^@]+)@([^@]+)$/);
+				if (match != null) {
+					if (new URL(`https://${match[2]}/`).hostname !== actorId.hostname && !await verifyCrossOriginActorHandle(actorId.href, alias, options.userAgent, options.tracerProvider, options.meterProvider)) continue;
+					return normalizeActorHandle(`@${match[1]}@${match[2]}`, options);
+				}
+			}
+		}
+	}
+	if (!(actor instanceof URL) && actor.preferredUsername != null && actor.id != null) return normalizeActorHandle(`@${actor.preferredUsername}@${actor.id.host}`, options);
+	throw new ActorHandleNotFoundError();
+}
+function isPortableActorId(id) {
+	return id.protocol === "ap:" || id.protocol === "ap+ef61:";
+}
+/**
+* The reverse discovery of an FEP-ef61 portable actor's WebFinger address,
+* which takes the domain from the first gateway in its `gateways`.
+*/
+async function getPortableActorHandle(actor, actorId, options) {
+	const gateway = actor.gateway;
+	const username = actor.preferredUsername?.toString();
+	if (gateway == null || !isGatewayUrl(gateway) || username == null) throw new ActorHandleNotFoundError();
+	const canonicalId = canonicalizePortableUri(formatIri(actorId));
+	const handle = `acct:${username}@${gateway.host}`;
+	const result = await lookupWebFinger(handle, {
+		userAgent: options.userAgent,
+		tracerProvider: options.tracerProvider,
+		meterProvider: options.meterProvider
+	});
+	if (result == null || !linksToPortableActor(result, canonicalId)) throw new ActorHandleNotFoundError();
+	const subject = result.subject?.match(/^acct:([^@]+)@([^@]+)$/);
+	if (subject != null && result.subject !== handle) {
+		const subjectResult = await lookupWebFinger(result.subject, {
+			userAgent: options.userAgent,
+			tracerProvider: options.tracerProvider,
+			meterProvider: options.meterProvider
+		});
+		if (subjectResult != null && linksToPortableActor(subjectResult, canonicalId)) return normalizeActorHandle(`@${subject[1]}@${subject[2]}`, options);
+	}
+	return normalizeActorHandle(`@${username}@${gateway.host}`, options);
+}
+/**
+* Checks if the first ActivityStreams `self` link of a WebFinger response
+* identifies the portable actor, either by its portable ID or by
+* a compatible identifier.
+*/
+function linksToPortableActor(jrd, canonicalId) {
+	const link = jrd.links?.find((l) => l.rel === "self" && l.href != null && (l.type === "application/activity+json" || l.type?.match(/application\/ld\+json;\s*profile="https:\/\/www.w3.org\/ns\/activitystreams"/) != null));
+	if (link?.href == null) return false;
+	try {
+		let id;
+		if (/^ap(?:\+ef61)?:/i.test(link.href)) id = link.href;
+		else {
+			const portable = URL.canParse(link.href) ? fromCompatibleEf61Id(link.href) : null;
+			if (portable == null) return false;
+			id = formatIri(portable);
+		}
+		return canonicalizePortableUri(id) === canonicalId;
+	} catch (error) {
+		if (error instanceof TypeError) return false;
+		throw error;
+	}
+}
+async function verifyCrossOriginActorHandle(actorId, alias, userAgent, tracerProvider, meterProvider) {
+	const response = await lookupWebFinger(alias, {
+		userAgent,
+		tracerProvider,
+		meterProvider
+	});
+	if (response == null) return false;
+	for (const alias of response.aliases ?? []) if (new URL(alias).href === actorId) return true;
+	return false;
+}
+/**
+* Normalizes the given actor handle.
+* @param handle The full handle of the actor to normalize.
+* @param options The options for normalizing the actor handle.
+* @returns The normalized actor handle.
+* @throws {TypeError} If the actor handle is invalid.
+* @since 0.9.0
+*/
+function normalizeActorHandle(handle, options = {}) {
+	handle = handle.replace(/^@/, "");
+	const atPos = handle.indexOf("@");
+	if (atPos < 1) throw new TypeError("Invalid actor handle.");
+	let domain = handle.substring(atPos + 1);
+	if (domain.length < 1 || domain.includes("@")) throw new TypeError("Invalid actor handle.");
+	domain = domain.toLowerCase();
+	domain = options.punycode ? domainToASCII(domain) : domainToUnicode(domain);
+	domain = domain.toLowerCase();
+	const user = handle.substring(0, atPos);
+	return options.trimLeadingAt ? `${user}@${domain}` : `@${user}@${domain}`;
+}
+//#endregion
+export { normalizeActorHandle as a, isActor as i, getActorHandle as n, name as o, getActorTypeName as r, version as s, getActorClassByTypeName as t };

package/dist-tests/actor.test.mjs

@@ -1,7 +1,8 @@
 import "temporal-polyfill";
 globalThis.addEventListener = () => {};
-import { K as __exportAll, M as Person, a as Application, j as Organization, v as Group, z as Service } from "./vocab-Bjwctrxn.mjs";
-import { a as normalizeActorHandle, c as esm_default, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-MBpzF3-D.mjs";
+import { F as Person, P as Organization, Q as __exportAll, U as Service, a as Application, b as Group } from "./vocab-DaniQwU7.mjs";
+import { t as esm_default } from "./esm-YWo4aQQe.mjs";
+import { a as normalizeActorHandle, i as isActor, n as getActorHandle, r as getActorTypeName, t as getActorClassByTypeName } from "./actor-D_QaCMro.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
@@ -1816,7 +1817,10 @@ function stringifyInternal(value, previousValues, getAsyncContent) {
 			if (typeof safeBufferIsBuffer === "function" && safeBufferIsBuffer(value)) return `Buffer.from(${stringifyInternal(safeArrayFrom(value.values()), currentValues, getAsyncContent)})`;
 			const valuePrototype = safeObjectGetPrototypeOf$1(value);
 			const className = valuePrototype && valuePrototype.constructor && valuePrototype.constructor.name;
-			if (typeof className === "string") return `${className}.from(${stringifyInternal(safeArrayFrom(value.values()), currentValues, getAsyncContent)})`;
+			if (typeof className === "string") {
+				const valuesFromTypedArr = value.values();
+				return `${className}.from(${stringifyInternal(safeArrayFrom(valuesFromTypedArr), currentValues, getAsyncContent)})`;
+			}
 			break;
 		}
 	}
@@ -2812,7 +2816,8 @@ function maxGeneratedLengthFromSizeForArbitrary(size, minLength, maxLength, spec
 	const { baseSize: defaultSize = DefaultSize, defaultSizeToMaxWhenMaxSpecified } = readConfigureGlobal() || {};
 	const definedSize = size !== void 0 ? size : specifiedMaxLength && defaultSizeToMaxWhenMaxSpecified ? "max" : defaultSize;
 	if (definedSize === "max") return maxLength;
-	return safeMathMin$3(maxLengthFromMinLength(minLength, relativeSizeToSize(definedSize, defaultSize)), maxLength);
+	const finalSize = relativeSizeToSize(definedSize, defaultSize);
+	return safeMathMin$3(maxLengthFromMinLength(minLength, finalSize), maxLength);
 }
 function depthBiasFromSizeForArbitrary(depthSizeOrSize, specifiedMaxDepth) {
 	if (typeof depthSizeOrSize === "number") return 1 / depthSizeOrSize;
@@ -3312,11 +3317,12 @@ var FrequencyArbitrary = class FrequencyArbitrary extends Arbitrary {
 			if (currentWeight < 0) throw new Error(`${label} expects weights to be superior or equal to 0`);
 		}
 		if (totalWeight <= 0) throw new Error(`${label} expects the sum of weights to be strictly superior to 0`);
-		return new FrequencyArbitrary(warbs, {
+		const sanitizedConstraints = {
 			depthBias: depthBiasFromSizeForArbitrary(constraints.depthSize, constraints.maxDepth !== void 0),
 			maxDepth: constraints.maxDepth != void 0 ? constraints.maxDepth : safePositiveInfinity$7,
 			withCrossShrink: !!constraints.withCrossShrink
-		}, getDepthContextFor(constraints.depthIdentifier));
+		};
+		return new FrequencyArbitrary(warbs, sanitizedConstraints, getDepthContextFor(constraints.depthIdentifier));
 	}
 	constructor(warbs, constraints, context) {
 		super();
@@ -4942,7 +4948,7 @@ const INDEX_NEGATIVE_INFINITY$1 = {
 	sign: -1,
 	data: [2146435072, 1]
 };
-const f64 = new Float64Array(1);
+const f64 = /* @__PURE__ */ new Float64Array(1);
 const u32$1 = new Uint32Array(f64.buffer, f64.byteOffset);
 function bitCastDoubleToUInt64(f) {
 	f64[0] = f;
@@ -5047,7 +5053,7 @@ function doubleOnlyMapper(value) {
 }
 function doubleOnlyUnmapper(value) {
 	if (typeof value !== "number") throw new Error("Unsupported type");
-	return value === safePositiveInfinity$4 ? onlyIntegersAfterThisValue$1 : value === safeNegativeInfinity$4 ? -onlyIntegersAfterThisValue$1 : value;
+	return value === safePositiveInfinity$4 ? onlyIntegersAfterThisValue$1 : value === safeNegativeInfinity$4 ? -4503599627370496 : value;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/double.js
@@ -5099,7 +5105,7 @@ const safePositiveInfinity$2 = Number.POSITIVE_INFINITY;
 const MAX_VALUE_32 = 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23);
 const INDEX_POSITIVE_INFINITY = 2139095040;
 const INDEX_NEGATIVE_INFINITY = -2139095041;
-const f32 = new Float32Array(1);
+const f32 = /* @__PURE__ */ new Float32Array(1);
 const u32 = new Uint32Array(f32.buffer, f32.byteOffset);
 function bitCastFloatToUInt32(f) {
 	f32[0] = f;
@@ -5155,7 +5161,7 @@ function floatOnlyMapper(value) {
 }
 function floatOnlyUnmapper(value) {
 	if (typeof value !== "number") throw new Error("Unsupported type");
-	return value === safePositiveInfinity$1 ? onlyIntegersAfterThisValue : value === safeNegativeInfinity$1 ? -onlyIntegersAfterThisValue : value;
+	return value === safePositiveInfinity$1 ? onlyIntegersAfterThisValue : value === safeNegativeInfinity$1 ? -8388608 : value;
 }
 //#endregion
 //#region ../../node_modules/.pnpm/fast-check@3.23.2/node_modules/fast-check/lib/esm/arbitrary/float.js
@@ -5643,50 +5649,50 @@ test({
 	},
 	async fn(t) {
 		esm_default.spyGlobal();
-		esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
-			body: { subject: "acct:johndoe@foo.example.com" },
+		esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
+			body: { subject: "acct:johndoe@1.1.1.1" },
 			headers: { "Content-Type": "application/jrd+json" }
 		});
-		const actorId = new URL("https://foo.example.com/@john");
+		const actorId = new URL("https://1.1.1.1/@john");
 		const actor = new Person({
 			id: actorId,
 			preferredUsername: "john"
 		});
 		await t.step("WebFinger subject", async () => {
-			deepStrictEqual(await getActorHandle(actor), "@johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actor, { trimLeadingAt: true }), "johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actorId), "@johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@foo.example.com");
+			deepStrictEqual(await getActorHandle(actor), "@johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actor, { trimLeadingAt: true }), "johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actorId), "@johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@1.1.1.1");
 		});
 		esm_default.removeRoutes();
-		esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
+		esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
 			body: {
-				subject: "https://foo.example.com/@john",
-				aliases: ["acct:john@bar.example.com", "acct:johndoe@foo.example.com"]
+				subject: "https://1.1.1.1/@john",
+				aliases: ["acct:john@8.8.8.8", "acct:johndoe@1.1.1.1"]
 			},
 			headers: { "Content-Type": "application/jrd+json" }
 		});
 		await t.step("WebFinger aliases", async () => {
-			deepStrictEqual(await getActorHandle(actor), "@johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actor, { trimLeadingAt: true }), "johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actorId), "@johndoe@foo.example.com");
-			deepStrictEqual(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@foo.example.com");
+			deepStrictEqual(await getActorHandle(actor), "@johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actor, { trimLeadingAt: true }), "johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actorId), "@johndoe@1.1.1.1");
+			deepStrictEqual(await getActorHandle(actorId, { trimLeadingAt: true }), "johndoe@1.1.1.1");
 		});
-		esm_default.get("begin:https://bar.example.com/.well-known/webfinger?", {
+		esm_default.get("begin:https://8.8.8.8/.well-known/webfinger?", {
 			body: {
-				subject: "acct:john@bar.example.com",
-				aliases: ["https://foo.example.com/@john"]
+				subject: "acct:john@8.8.8.8",
+				aliases: ["https://1.1.1.1/@john"]
 			},
 			headers: { "Content-Type": "application/jrd+json" }
 		});
 		await t.step("cross-origin WebFinger resources", async () => {
-			deepStrictEqual(await getActorHandle(actor), "@john@bar.example.com");
+			deepStrictEqual(await getActorHandle(actor), "@john@8.8.8.8");
 		});
 		esm_default.removeRoutes();
-		esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", { status: 404 });
+		esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", { status: 404 });
 		await t.step("no WebFinger", async () => {
-			deepStrictEqual(await getActorHandle(actor), "@john@foo.example.com");
-			rejects(() => getActorHandle(actorId), TypeError);
+			deepStrictEqual(await getActorHandle(actor), "@john@1.1.1.1");
+			await rejects(() => getActorHandle(actorId), TypeError);
 		});
 		esm_default.hardReset();
 	}
@@ -5697,25 +5703,25 @@ test("getActorHandle() records activitypub.actor.discovery counter", { permissio
 } }, async (t) => {
 	esm_default.spyGlobal();
 	try {
-		const actorId = new URL("https://foo.example.com/@john");
+		const actorId = new URL("https://1.1.1.1/@john");
 		const actor = new Person({
 			id: actorId,
 			preferredUsername: "john"
 		});
 		await t.step("records result=resolved on a successful lookup", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
-				body: { subject: "acct:johndoe@foo.example.com" },
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
+				body: { subject: "acct:johndoe@1.1.1.1" },
 				headers: { "Content-Type": "application/jrd+json" }
 			});
 			const [meterProvider, recorder] = createTestMeterProvider();
-			deepStrictEqual(await getActorHandle(actor, { meterProvider }), "@johndoe@foo.example.com");
+			deepStrictEqual(await getActorHandle(actor, { meterProvider }), "@johndoe@1.1.1.1");
 			const counters = recorder.getMeasurements("activitypub.actor.discovery");
 			deepStrictEqual(counters.length, 1);
 			deepStrictEqual(counters[0].type, "counter");
 			deepStrictEqual(counters[0].value, 1);
 			deepStrictEqual(counters[0].attributes["activitypub.actor.discovery.result"], "resolved");
-			deepStrictEqual(counters[0].attributes["activitypub.remote.host"], "foo.example.com");
+			deepStrictEqual(counters[0].attributes["activitypub.remote.host"], "1.1.1.1");
 			const durations = recorder.getMeasurements("activitypub.actor.discovery.duration");
 			deepStrictEqual(durations.length, 1);
 			deepStrictEqual(durations[0].type, "histogram");
@@ -5724,40 +5730,40 @@ test("getActorHandle() records activitypub.actor.discovery counter", { permissio
 		});
 		await t.step("records result=resolved when WebFinger is missing but preferredUsername fallback succeeds", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", { status: 404 });
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", { status: 404 });
 			const [meterProvider, recorder] = createTestMeterProvider();
-			deepStrictEqual(await getActorHandle(actor, { meterProvider }), "@john@foo.example.com");
+			deepStrictEqual(await getActorHandle(actor, { meterProvider }), "@john@1.1.1.1");
 			const counter = recorder.getMeasurement("activitypub.actor.discovery");
 			ok(counter != null);
 			deepStrictEqual(counter.attributes["activitypub.actor.discovery.result"], "resolved");
 		});
 		await t.step("records result=not_found when neither WebFinger nor preferredUsername yields a handle", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", { status: 404 });
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", { status: 404 });
 			const [meterProvider, recorder] = createTestMeterProvider();
 			await rejects(() => getActorHandle(actorId, { meterProvider }), TypeError);
 			const counter = recorder.getMeasurement("activitypub.actor.discovery");
 			ok(counter != null);
 			deepStrictEqual(counter.attributes["activitypub.actor.discovery.result"], "not_found");
-			deepStrictEqual(counter.attributes["activitypub.remote.host"], "foo.example.com");
+			deepStrictEqual(counter.attributes["activitypub.remote.host"], "1.1.1.1");
 			const duration = recorder.getMeasurement("activitypub.actor.discovery.duration");
 			ok(duration != null);
 			deepStrictEqual(duration.attributes["activitypub.actor.discovery.result"], "not_found");
 		});
 		await t.step("records non-default ports for actor IDs", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com:8443/.well-known/webfinger?", { status: 404 });
+			esm_default.get("begin:https://1.1.1.1:8443/.well-known/webfinger?", { status: 404 });
 			const [meterProvider, recorder] = createTestMeterProvider();
-			await rejects(() => getActorHandle(new URL("https://foo.example.com:8443/@john"), { meterProvider }), TypeError);
+			await rejects(() => getActorHandle(new URL("https://1.1.1.1:8443/@john"), { meterProvider }), TypeError);
 			const counter = recorder.getMeasurement("activitypub.actor.discovery");
 			ok(counter != null);
-			deepStrictEqual(counter.attributes["activitypub.remote.host"], "foo.example.com:8443");
+			deepStrictEqual(counter.attributes["activitypub.remote.host"], "1.1.1.1:8443");
 		});
 		await t.step("records result=error when a malformed WebFinger alias throws TypeError", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
 				body: {
-					subject: "https://foo.example.com/@john",
+					subject: "https://1.1.1.1/@john",
 					aliases: ["acct:john@["]
 				},
 				headers: { "Content-Type": "application/jrd+json" }
@@ -5770,8 +5776,8 @@ test("getActorHandle() records activitypub.actor.discovery counter", { permissio
 		});
 		await t.step("propagates meterProvider into the nested webfinger.lookup", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
-				body: { subject: "acct:johndoe@foo.example.com" },
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
+				body: { subject: "acct:johndoe@1.1.1.1" },
 				headers: { "Content-Type": "application/jrd+json" }
 			});
 			const [meterProvider, recorder] = createTestMeterProvider();
@@ -5782,8 +5788,8 @@ test("getActorHandle() records activitypub.actor.discovery counter", { permissio
 		});
 		await t.step("omits measurements when no meterProvider is provided", async () => {
 			esm_default.removeRoutes();
-			esm_default.get("begin:https://foo.example.com/.well-known/webfinger?", {
-				body: { subject: "acct:johndoe@foo.example.com" },
+			esm_default.get("begin:https://1.1.1.1/.well-known/webfinger?", {
+				body: { subject: "acct:johndoe@1.1.1.1" },
 				headers: { "Content-Type": "application/jrd+json" }
 			});
 			const [_unused, recorder] = createTestMeterProvider();