@fedify/cli 2.3.0-dev.994 → 2.3.1

package/dist/bench/scenarios/inbox.js

@@ -0,0 +1,147 @@
+import "@js-temporal/polyfill";
+import { discoverInbox, selectInbox } from "../discovery/discover.js";
+import { asList } from "../scenario/coerce.js";
+import { runLoad } from "../load/generator.js";
+import { aggregateSamples } from "../metrics/aggregate.js";
+import { diffSnapshots, fetchServerSnapshot, snapshotToMetrics } from "../metrics/stats-client.js";
+import { createSigningPipeline } from "../signing/pipeline.js";
+import { estimateTotal, loadPlanOf, measuredWindowMs, sendRequest, validateInboxSelector, withMeasuredWindowStart } from "./runner.js";
+import { createActivityIdMinter } from "../signing/activity-id.js";
+import { signInboxDelivery } from "../signing/signer.js";
+import { isGenerateDirective, resolveGenerate } from "../template/generate.js";
+import { Create, Note } from "@fedify/vocab";
+//#region src/bench/scenarios/inbox.ts
+/**
+* The `inbox` scenario runner: the end-to-end signed-delivery benchmark.
+*
+* It discovers the recipient's inbox the way a real peer does, then drives
+* signed activity deliveries through the signing pipeline, aggregates the
+* client-measured results, and reads the target's server-side metrics.
+* @since 2.3.0
+* @module
+*/
+/** The `inbox` scenario runner. */
+const inboxRunner = {
+	validate(scenario) {
+		validateActivity(scenario);
+		validateInbox(scenario);
+	},
+	async run(context) {
+		const { scenario, fleet } = context;
+		if (fleet == null || fleet.actors.length < 1) throw new Error("The inbox scenario requires the synthetic actor server.");
+		if (scenario.recipients.length < 1) throw new Error("The inbox scenario requires a recipient.");
+		validateActivity(scenario);
+		validateInbox(scenario);
+		const fetchImpl = context.fetch ?? fetch;
+		const targets = [];
+		for (const recipient of scenario.recipients) {
+			const discovered = await discoverInbox(recipient, {
+				documentLoader: context.documentLoader,
+				contextLoader: context.contextLoader,
+				allowPrivateAddress: context.allowPrivateAddress
+			});
+			const inbox = selectInbox(discovered, scenario.inbox);
+			await context.assertDestinationAllowed?.(inbox);
+			targets.push({
+				inbox,
+				actorUri: discovered.actorUri
+			});
+		}
+		const actors = fleet.actors;
+		const minter = createActivityIdMinter(fleet.url);
+		let index = 0;
+		const factory = () => {
+			const i = index++;
+			const actor = actors[i % actors.length];
+			const target = targets[i % targets.length];
+			const activity = buildActivity(scenario.activity, actor, minter.next(), fleet.url, target.actorUri);
+			return signInboxDelivery({
+				actor,
+				inbox: target.inbox,
+				activity,
+				contextLoader: context.contextLoader
+			});
+		};
+		const pipeline = createSigningPipeline(scenario.signing, factory, { total: estimateTotal(scenario) });
+		const rawSend = async () => {
+			let request;
+			try {
+				request = await pipeline.next();
+			} catch (error) {
+				return {
+					ok: false,
+					errorKind: "client",
+					reason: String(error)
+				};
+			}
+			return sendRequest(request, fetchImpl);
+		};
+		let baseline = null;
+		let baselineTaken = false;
+		const send = withMeasuredWindowStart(scenario.warmupMs, async () => {
+			baseline = await fetchServerSnapshot(context.target, fetchImpl);
+			baselineTaken = true;
+		}, rawSend);
+		try {
+			await pipeline.prime();
+			const measurement = aggregateSamples((await runLoad(loadPlanOf(scenario, context.rng), send, context.clock, context.signal)).samples, {
+				measuredWindowMs: measuredWindowMs(scenario),
+				includeHistogram: true
+			});
+			const end = await fetchServerSnapshot(context.target, fetchImpl);
+			const server = baselineTaken && baseline != null && end != null ? snapshotToMetrics(diffSnapshots(baseline, end)) : null;
+			return {
+				...measurement,
+				server
+			};
+		} finally {
+			await pipeline.close();
+		}
+	}
+};
+/**
+* Validates the scenario's `inbox` mode.  `"shared"` and `"personal"` select a
+* discovered inbox; any other value is an explicit inbox URL the run will POST
+* to, so it must be a usable bare http(s) URL.  Without this preflight check, a
+* typo like `inbox: shraed` would crash `selectInbox` with an uncaught error
+* mid-run, and a non-http URL would slip through to the send path.
+*/
+function validateInbox(scenario) {
+	validateInboxSelector(scenario.name, scenario.inbox);
+}
+/**
+* Rejects the activity options the inbox runner cannot yet honor: it always
+* delivers a `Create` carrying an embedded `Note`, so a different activity or
+* object type, or `embedObject: false`, is refused with a clear message.
+*/
+function validateActivity(scenario) {
+	const spec = scenario.activity;
+	if (spec == null) return;
+	const badType = asList(spec.type).find((type) => type !== "Create");
+	if (badType != null) throw new Error(`Scenario "${scenario.name}": the inbox runner currently supports only Create activities; got ${JSON.stringify(badType)}.`);
+	if (spec.embedObject === false) throw new Error(`Scenario "${scenario.name}": the inbox runner always embeds the activity's object; embedObject: false is not yet supported.`);
+	const badObjectType = asList(spec.object?.type).find((type) => type !== "Note");
+	if (badObjectType != null) throw new Error(`Scenario "${scenario.name}": the inbox runner currently supports only Note objects; got ${JSON.stringify(badObjectType)}.`);
+}
+function buildActivity(spec, actor, id, base, recipient) {
+	const note = new Note({
+		id: new URL(`/objects/${crypto.randomUUID()}`, base),
+		attribution: actor.id,
+		content: resolveContent(spec?.object?.content),
+		to: recipient
+	});
+	return new Create({
+		id,
+		actor: actor.id,
+		object: note,
+		to: recipient
+	});
+}
+function resolveContent(content) {
+	if (content == null) return "Benchmark activity.";
+	if (typeof content === "string") return content;
+	if (isGenerateDirective(content)) return resolveGenerate(content);
+	return String(content);
+}
+//#endregion
+export { inboxRunner };

package/dist/bench/scenarios/mixed.js

@@ -0,0 +1,244 @@
+import "@js-temporal/polyfill";
+import { LogLinearHistogram } from "../metrics/histogram.js";
+import { actorRunner } from "./actor.js";
+import { fanoutRunner } from "./fanout.js";
+import { failureRunner } from "./failure.js";
+import { inboxRunner } from "./inbox.js";
+import { objectRunner } from "./object.js";
+import { webfingerRunner } from "./webfinger.js";
+//#region src/bench/scenarios/mixed.ts
+/**
+* The `mixed` scenario runner.
+* @since 2.3.0
+* @module
+*/
+/** The `mixed` scenario runner. */
+const mixedRunner = {
+	validate(scenario, context) {
+		if (scenario.raw.mix == null || scenario.raw.mix.length < 1) throw new Error(`Scenario "${scenario.name}": mixed requires at least one mix entry.`);
+		for (const entry of scenario.raw.mix) if (entry.weight <= 0) throw new Error(`Scenario "${scenario.name}": mix entry ${entry.scenario} has a non-positive weight.`);
+		if (scenario.load.kind === "closed" && scenario.load.concurrency < scenario.raw.mix.length) throw new Error(`Scenario "${scenario.name}": closed-loop mixed load needs at least one concurrency slot per mix entry.`);
+		const serverExpectation = Object.keys(scenario.expect).find(isServerExpectation);
+		if (serverExpectation != null) throw new Error(`Scenario "${scenario.name}": mixed server-side expectations are not supported (${JSON.stringify(serverExpectation)}).`);
+		if (context?.scenarios != null) {
+			const children = childScenarios(scenario, context.scenarios);
+			for (const child of children) runnerForChild(child.type).validate?.(child, context);
+			validateTargetQueueObservation(scenario, children);
+		}
+	},
+	async run(context) {
+		this.validate?.(context.scenario, { scenarios: context.scenarios });
+		if (context.scenarios == null) throw new Error("The mixed scenario requires the resolved scenario list.");
+		const children = childScenarios(context.scenario, context.scenarios);
+		const fetchImpl = limitedFetch(context.fetch ?? fetch, context.scenario.load.maxInFlight);
+		const results = await Promise.allSettled(children.map((child) => runnerForChild(child.type).run({
+			...context,
+			scenario: child,
+			fetch: fetchImpl,
+			assertDestinationAllowed: (url, scenario) => context.assertDestinationAllowed?.(url, scenario ?? child),
+			assertReadDestinationAllowed: (url, scenario) => context.assertReadDestinationAllowed?.(url, scenario ?? child),
+			assertActorlessDestinationAllowed: (url, scenario) => context.assertActorlessDestinationAllowed?.(url, scenario ?? child)
+		})));
+		const rejected = results.find((result) => result.status === "rejected");
+		if (rejected != null) throw rejected.reason;
+		return mergeMeasurements(results.filter((result) => result.status === "fulfilled").map((result) => result.value));
+	}
+};
+function isServerExpectation(metric) {
+	return metric.startsWith("signatureVerification.") || metric.startsWith("queueDrain.");
+}
+function validateTargetQueueObservation(scenario, children) {
+	const observers = children.filter(observesTargetQueue);
+	if (observers.length < 1) return;
+	if (children.filter(producesTargetQueue).length <= 1) return;
+	throw new Error(`Scenario "${scenario.name}": mixed scenarios cannot run queue-observing children (${observers.map((child) => child.name).join(", ")}) concurrently with other target queue producers because target queue counters are not scoped per child.`);
+}
+function observesTargetQueue(scenario) {
+	return scenario.type === "fanout" || scenario.type === "failure" && faultsOf(scenario).some(isRemoteFault);
+}
+function producesTargetQueue(scenario) {
+	return scenario.type === "inbox" || scenario.type === "fanout" || scenario.type === "failure" && faultsOf(scenario).some(isRemoteFault);
+}
+function faultsOf(scenario) {
+	return scenario.faults.length < 1 ? ["remote-404"] : scenario.faults;
+}
+function isRemoteFault(fault) {
+	return fault === "remote-404" || fault === "remote-410" || fault === "slow-inbox" || fault === "network-error";
+}
+function childScenarios(scenario, scenarios) {
+	const entries = scenario.raw.mix ?? [];
+	const totalWeight = entries.reduce((sum, entry) => sum + entry.weight, 0);
+	const closedLoads = scenario.load.kind === "closed" ? scaledClosedConcurrencies(scenario.load.concurrency, entries.map((entry) => entry.weight)) : void 0;
+	return entries.map((entry, index) => {
+		const children = scenarios.filter((candidate) => candidate.name === entry.scenario);
+		const child = children[0];
+		if (child == null) throw new Error(`Scenario "${scenario.name}": unknown mixed child ${JSON.stringify(entry.scenario)}.`);
+		if (children.length > 1) throw new Error(`Scenario "${scenario.name}": ambiguous mixed child ${JSON.stringify(entry.scenario)} matches ${children.length} scenarios.`);
+		if (child.type === "mixed") throw new Error(`Scenario "${scenario.name}": nested mixed scenarios are not supported.`);
+		const load = scaledLoad(scenario.load, entry.weight, totalWeight, closedLoads?.[index]);
+		return {
+			...child,
+			name: `${scenario.name}/${child.name}`,
+			load,
+			durationMs: scenario.durationMs,
+			warmupMs: scenario.warmupMs,
+			signing: scenario.signing,
+			signatureTimeWindow: scenario.signatureTimeWindow,
+			expect: {},
+			raw: {
+				...child.raw,
+				name: `${scenario.name}/${child.name}`,
+				load: rawLoad(load),
+				duration: `${scenario.durationMs}ms`,
+				warmup: `${scenario.warmupMs}ms`,
+				signing: scenario.signing,
+				signatureTimeWindow: scenario.signatureTimeWindow,
+				expect: {}
+			}
+		};
+	});
+}
+function scaledLoad(load, weight, totalWeight, closedConcurrency) {
+	if (load.kind === "open") return {
+		kind: "open",
+		ratePerSec: load.ratePerSec * (weight / totalWeight),
+		arrival: load.arrival
+	};
+	return {
+		kind: "closed",
+		concurrency: closedConcurrency ?? Math.max(1, Math.round(load.concurrency * weight / totalWeight))
+	};
+}
+function limitedFetch(fetchImpl, maxInFlight) {
+	if (maxInFlight == null) return fetchImpl;
+	const limiter = createLimiter(maxInFlight);
+	const limited = async (input, init) => {
+		const release = await limiter.acquire();
+		try {
+			return await fetchImpl(input, init);
+		} finally {
+			release();
+		}
+	};
+	return limited;
+}
+function createLimiter(maxInFlight) {
+	if (!Number.isInteger(maxInFlight) || maxInFlight < 1) throw new RangeError(`maxInFlight must be a positive integer; got ${maxInFlight}.`);
+	let active = 0;
+	const waiters = [];
+	return { async acquire() {
+		if (active < maxInFlight) active++;
+		else await new Promise((resolve) => waiters.push(resolve));
+		let released = false;
+		return () => {
+			if (released) return;
+			released = true;
+			const next = waiters.shift();
+			if (next == null) active--;
+			else next();
+		};
+	} };
+}
+function scaledClosedConcurrencies(concurrency, weights) {
+	const totalWeight = weights.reduce((sum, weight) => sum + weight, 0);
+	const ideal = weights.map((weight) => concurrency * weight / totalWeight);
+	const allocations = weights.map(() => 1);
+	for (let remaining = concurrency - weights.length; remaining > 0; remaining--) {
+		let best = 0;
+		for (let i = 1; i < allocations.length; i++) if (ideal[i] - allocations[i] > ideal[best] - allocations[best]) best = i;
+		allocations[best]++;
+	}
+	return allocations;
+}
+function rawLoad(load) {
+	if (load.kind === "open") return {
+		rate: load.ratePerSec,
+		arrival: load.arrival,
+		maxInFlight: load.maxInFlight
+	};
+	return {
+		concurrency: load.concurrency,
+		maxInFlight: load.maxInFlight
+	};
+}
+function runnerForChild(type) {
+	switch (type) {
+		case "inbox": return inboxRunner;
+		case "webfinger": return webfingerRunner;
+		case "actor": return actorRunner;
+		case "object": return objectRunner;
+		case "fanout": return fanoutRunner;
+		case "failure": return failureRunner;
+		default: throw new Error(`The "${type}" scenario type cannot be used inside a mixed scenario.`);
+	}
+}
+function mergeMeasurements(measurements) {
+	const total = measurements.reduce((sum, m) => sum + m.requests.total, 0);
+	const ok = measurements.reduce((sum, m) => sum + m.requests.ok, 0);
+	const histogram = mergeHistograms(measurements);
+	const deliveryThroughputs = measurements.map((m) => m.deliveryThroughputPerSec).filter((value) => value != null);
+	return {
+		requests: {
+			total,
+			ok,
+			failed: total - ok,
+			successRate: total === 0 ? 1 : ok / total
+		},
+		throughputPerSec: measurements.reduce((sum, m) => sum + m.throughputPerSec, 0),
+		...deliveryThroughputs.length < 1 ? {} : { deliveryThroughputPerSec: deliveryThroughputs.reduce((sum, value) => sum + value, 0) },
+		client: { latencyMs: histogram == null ? mergeLatencyFallback(measurements) : latencyFromHistogram(histogram) },
+		server: null,
+		errors: mergeErrors(measurements),
+		...histogram == null ? {} : { histogram: histogram.toJSON() }
+	};
+}
+function mergeHistograms(measurements) {
+	let merged = null;
+	for (const measurement of measurements) {
+		if (measurement.histogram == null) return null;
+		const histogram = LogLinearHistogram.fromJSON(measurement.histogram);
+		if (merged == null) merged = histogram;
+		else merged.merge(histogram);
+	}
+	return merged;
+}
+function latencyFromHistogram(histogram) {
+	return {
+		p50: histogram.percentile(50),
+		p95: histogram.percentile(95),
+		p99: histogram.percentile(99),
+		mean: histogram.mean,
+		max: histogram.max
+	};
+}
+function mergeLatencyFallback(measurements) {
+	const total = measurements.reduce((sum, m) => sum + m.requests.total, 0);
+	if (measurements.length < 1) return {
+		p50: 0,
+		p95: 0,
+		p99: 0,
+		mean: 0,
+		max: 0
+	};
+	return {
+		p50: Math.max(...measurements.map((m) => m.client.latencyMs.p50)),
+		p95: Math.max(...measurements.map((m) => m.client.latencyMs.p95)),
+		p99: Math.max(...measurements.map((m) => m.client.latencyMs.p99)),
+		mean: total === 0 ? 0 : measurements.reduce((sum, m) => sum + m.client.latencyMs.mean * m.requests.total, 0) / total,
+		max: Math.max(...measurements.map((m) => m.client.latencyMs.max))
+	};
+}
+function mergeErrors(measurements) {
+	const buckets = /* @__PURE__ */ new Map();
+	for (const measurement of measurements) for (const error of measurement.errors) {
+		const key = `${error.kind}|${error.status ?? ""}|${error.reason}`;
+		const existing = buckets.get(key);
+		buckets.set(key, {
+			...error,
+			count: (existing?.count ?? 0) + error.count
+		});
+	}
+	return [...buckets.values()].sort((a, b) => b.count - a.count);
+}
+//#endregion
+export { mixedRunner };

package/dist/bench/scenarios/object-discovery.js

@@ -0,0 +1,211 @@
+import "@js-temporal/polyfill";
+import { convertUrlIfHandle } from "../../webfinger/lib.js";
+import { asList } from "../scenario/coerce.js";
+//#region src/bench/scenarios/object-discovery.ts
+/**
+* Discovery helpers for actor and object benchmark scenarios.
+* @since 2.3.0
+* @module
+*/
+const ACTIVITY_JSON_ACCEPT = "application/activity+json, application/ld+json";
+const WEBFINGER_ACCEPT = "application/jrd+json, application/json";
+const MAX_COLLECTION_CRAWL_PAGES = 100;
+const MAX_ACTIVITY_UNWRAP_DEPTH = 10;
+const ACTIVITY_WRAPPER_TYPES = new Set([
+	"Accept",
+	"Add",
+	"Announce",
+	"Create",
+	"Delete",
+	"Dislike",
+	"Flag",
+	"Ignore",
+	"Invite",
+	"Join",
+	"Leave",
+	"Like",
+	"Listen",
+	"Move",
+	"Offer",
+	"Question",
+	"Read",
+	"Reject",
+	"Remove",
+	"TentativeAccept",
+	"TentativeReject",
+	"Travel",
+	"Undo",
+	"Update",
+	"View"
+]);
+/** Resolves scenario recipients into actor document URLs. */
+async function actorUrlsFromRecipients(recipients, options) {
+	const urls = [];
+	for (const recipient of recipients) urls.push(await actorUrlFromRecipient(recipient, options));
+	return urls;
+}
+/** Resolves object scenario sources into object URLs. */
+async function objectUrlsFromSource(options) {
+	const { source } = options;
+	if (source == null) return [];
+	if (typeof source === "string" || Array.isArray(source)) return asList(source).map((url) => new URL(url));
+	const limit = source.limit ?? 100;
+	const types = new Set(asList(source.type));
+	const urls = [];
+	for (const seed of asList(source.seed)) {
+		const actorUrl = await actorUrlFromRecipient(seed, options);
+		await options.assertReadDestinationAllowed?.(actorUrl);
+		const actor = await fetchJson(actorUrl, options.fetch);
+		for (const collectionName of asList(source.collection ?? "outbox")) {
+			const collectionUrl = propertyUrl(actor, collectionName, actorUrl);
+			if (collectionUrl == null) continue;
+			for await (const objectUrl of crawlCollection(collectionUrl, {
+				fetch: options.fetch,
+				assertReadDestinationAllowed: options.assertReadDestinationAllowed,
+				types,
+				limit: limit - urls.length
+			})) {
+				urls.push(objectUrl);
+				if (urls.length >= limit) return urls;
+			}
+		}
+	}
+	return urls;
+}
+async function actorUrlFromRecipient(recipient, options) {
+	const identifier = convertUrlIfHandle(recipient);
+	if (identifier.protocol !== "acct:") return identifier;
+	const url = new URL("/.well-known/webfinger", options.target);
+	url.searchParams.set("resource", identifier.href);
+	const jrd = await fetchJson(url, options.fetch, WEBFINGER_ACCEPT);
+	const self = (Array.isArray(jrd.links) ? jrd.links : []).find((link) => isRecord(link) && link.rel === "self" && typeof link.href === "string");
+	if (!isRecord(self) || typeof self.href !== "string") throw new Error(`WebFinger response for ${recipient} has no self link.`);
+	return new URL(self.href);
+}
+async function* crawlCollection(start, options) {
+	let next = start;
+	let remaining = options.limit;
+	let pages = 0;
+	const visited = /* @__PURE__ */ new Set();
+	while (next != null && remaining > 0 && pages < MAX_COLLECTION_CRAWL_PAGES) {
+		if (visited.has(next.href)) return;
+		visited.add(next.href);
+		await options.assertReadDestinationAllowed?.(next);
+		const page = await fetchJson(next, options.fetch);
+		pages++;
+		const items = arrayProperty(page, "orderedItems") ?? arrayProperty(page, "items") ?? [];
+		for (const item of items) {
+			const url = await objectUrl(item, {
+				base: next,
+				fetch: options.fetch,
+				assertReadDestinationAllowed: options.assertReadDestinationAllowed,
+				types: options.types
+			});
+			if (url == null) continue;
+			yield url;
+			remaining--;
+			if (remaining <= 0) return;
+		}
+		const first = propertyUrl(page, "first", next);
+		next = propertyUrl(page, "next", next) ?? (next.href === start.href ? first : null);
+	}
+}
+async function fetchJson(url, fetchImpl = fetch, accept = ACTIVITY_JSON_ACCEPT) {
+	const response = await fetchImpl(new Request(url, {
+		headers: { accept },
+		redirect: "manual"
+	}));
+	if (!response.ok) {
+		await response.arrayBuffer().catch(() => {});
+		throw new Error(`Failed to fetch ${url.href}: HTTP ${response.status}.`);
+	}
+	let json;
+	try {
+		json = await response.json();
+	} catch (error) {
+		throw new Error(`Failed to parse JSON from ${url.href}: ${error}`);
+	}
+	if (!isRecord(json)) throw new Error(`Expected ${url.href} to return a JSON object.`);
+	return json;
+}
+async function objectUrl(item, options) {
+	for (const candidate of objectCandidates(item)) {
+		if (typeof candidate === "string") {
+			const url = safeUrl(candidate, options.base);
+			if (url == null) continue;
+			if (options.types.size < 1) return url;
+			const typedUrl = await typedReferencedObjectUrl(url, options);
+			if (typedUrl != null) return typedUrl;
+			continue;
+		}
+		if (!isRecord(candidate)) continue;
+		if (options.types.size > 0 && !matchesType(candidate.type, options.types)) continue;
+		const url = propertyUrl(candidate, "id", options.base);
+		if (url != null) return url;
+	}
+	return null;
+}
+async function typedReferencedObjectUrl(url, options, seen = /* @__PURE__ */ new Set(), depth = 0) {
+	if (depth > MAX_ACTIVITY_UNWRAP_DEPTH) return null;
+	if (seen.has(url.href)) return null;
+	seen.add(url.href);
+	await options.assertReadDestinationAllowed?.(url);
+	let object;
+	try {
+		object = await fetchJson(url, options.fetch);
+	} catch {
+		return null;
+	}
+	for (const candidate of objectCandidates(object)) {
+		if (typeof candidate === "string") {
+			const candidateUrl = safeUrl(candidate, url);
+			if (candidateUrl == null) continue;
+			const typedUrl = await typedReferencedObjectUrl(candidateUrl, options, seen, depth + 1);
+			if (typedUrl != null) return typedUrl;
+			continue;
+		}
+		if (!isRecord(candidate)) continue;
+		if (!matchesType(candidate.type, options.types)) continue;
+		return propertyUrl(candidate, "id", url) ?? url;
+	}
+	return null;
+}
+function objectCandidates(item, depth = 0, seen = /* @__PURE__ */ new WeakSet()) {
+	if (depth > MAX_ACTIVITY_UNWRAP_DEPTH) return [];
+	if (!isRecord(item) || !matchesType(item.type, ACTIVITY_WRAPPER_TYPES)) return [item];
+	if (seen.has(item)) return [];
+	seen.add(item);
+	const object = item.object;
+	if (object == null) return [];
+	if (Array.isArray(object)) return object.flatMap((entry) => entry == null ? [] : objectCandidates(entry, depth + 1, seen));
+	return objectCandidates(object, depth + 1, seen);
+}
+function matchesType(type, expected) {
+	if (typeof type === "string") return expected.has(type);
+	return Array.isArray(type) && type.some((item) => typeof item === "string" && expected.has(item));
+}
+function propertyUrl(object, key, base) {
+	const value = object[key];
+	if (typeof value === "string") return safeUrl(value, base);
+	if (isRecord(value)) {
+		if (typeof value.href === "string") return safeUrl(value.href, base);
+		if (typeof value.id === "string") return safeUrl(value.id, base);
+	}
+	return null;
+}
+function arrayProperty(object, key) {
+	const value = object[key];
+	return Array.isArray(value) ? value : null;
+}
+function isRecord(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function safeUrl(value, base) {
+	try {
+		return new URL(value, base);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { actorUrlsFromRecipients, objectUrlsFromSource };

package/dist/bench/scenarios/object.js

@@ -0,0 +1,54 @@
+import "@js-temporal/polyfill";
+import { convertUrlIfHandle } from "../../webfinger/lib.js";
+import { asList } from "../scenario/coerce.js";
+import { objectUrlsFromSource } from "./object-discovery.js";
+import { assertBareHttpUrl, isBareHttpUrl } from "./runner.js";
+import { runReadLoad } from "./read.js";
+//#region src/bench/scenarios/object.ts
+/**
+* The `object` scenario runner.
+* @since 2.3.0
+* @module
+*/
+/** The `object` scenario runner. */
+const objectRunner = {
+	validate(scenario) {
+		const { source } = scenario;
+		if (source == null) return;
+		if (typeof source === "string" || Array.isArray(source)) {
+			for (const url of asList(source)) {
+				let parsed;
+				try {
+					parsed = new URL(url);
+				} catch {
+					throw new Error(`Scenario "${scenario.name}": invalid object source URL ${JSON.stringify(url)}.`);
+				}
+				assertBareHttpUrl(scenario.name, "object source URL", parsed);
+			}
+			return;
+		}
+		for (const seed of asList(source.seed)) {
+			let url;
+			try {
+				url = convertUrlIfHandle(seed);
+			} catch {
+				throw new Error(`Scenario "${scenario.name}": invalid object source seed URL ${JSON.stringify(seed)}.`);
+			}
+			if (url.protocol !== "acct:" && !isBareHttpUrl(url)) throw new Error(`Scenario "${scenario.name}": object source seed must be an acct: handle or a bare http(s) URL with a host and no credentials; got ${JSON.stringify(url.href)}.`);
+		}
+	},
+	async run(context) {
+		this.validate?.(context.scenario);
+		return await runReadLoad(context, {
+			urls: await objectUrlsFromSource({
+				source: context.scenario.source,
+				target: context.target,
+				fetch: context.fetch,
+				assertReadDestinationAllowed: context.assertReadDestinationAllowed
+			}),
+			authenticated: context.scenario.authenticated
+		});
+	}
+};
+//#endregion
+export { objectRunner };