@fedify/fedify 2.2.18 → 2.2.20

package/dist/otel/exporter.test.mjs

@@ -3,6 +3,7 @@ import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-Ew3jOFa3.mjs";
 import "../std__assert-DNZ4Liil.mjs";
+import { t as assert } from "../assert-BhQd8QHP.mjs";
 import { t as MemoryKvStore } from "../kv-mI4Ix2EU.mjs";
 import { test } from "@fedify/fixture";
 import { SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
@@ -193,33 +194,6 @@ var FedifySpanExporter = class {
 			record.spanId
 		];
 		await this.#kv.set(key, record, options);
-		await this.#updateTraceSummary(record, options);
-	}
-	async #setWithCasRetry(key, transform, options) {
-		if (this.#kv.cas != null) for (let attempt = 0; attempt < 3; attempt++) {
-			const existing = await this.#kv.get(key);
-			const newValue = transform(existing);
-			if (await this.#kv.cas(key, existing, newValue, options)) return;
-		}
-		const newValue = transform(await this.#kv.get(key));
-		await this.#kv.set(key, newValue, options);
-	}
-	async #updateTraceSummary(record, options) {
-		const summaryKey = [
-			...this.#keyPrefix,
-			"_summaries",
-			record.traceId
-		];
-		await this.#setWithCasRetry(summaryKey, (existing) => {
-			const activityCount = existing != null ? existing.activityCount + 1 : 1;
-			const activityTypes = existing != null ? existing.activityTypes.includes(record.activityType) ? existing.activityTypes : [...existing.activityTypes, record.activityType] : [record.activityType];
-			return {
-				traceId: existing?.traceId ?? record.traceId,
-				timestamp: existing?.timestamp ?? record.timestamp,
-				activityCount,
-				activityTypes
-			};
-		}, options);
 	}
 	/**
 	* Gets all activity records for a specific trace ID.
@@ -236,13 +210,46 @@ var FedifySpanExporter = class {
 	/**
 	* Gets recent traces with summary information.
 	*
+	* Each summary is computed directly from the activity records currently
+	* stored for each trace, rather than from a separately maintained
+	* counter.  This guarantees that a trace is discoverable, and its
+	* `activityCount` accurate, as soon as its records are stored, even if
+	* an earlier attempt at summarizing it (in a previous version of this
+	* exporter) never completed, and that the count always reflects
+	* records that have not expired.  It costs a full scan of every stored
+	* record on every call, including full inbound activity JSON.  The
+	* `limit` option only truncates the returned summaries and does not
+	* reduce the scan.  Callers that poll this method frequently should
+	* account for the total retained data when choosing a TTL and polling
+	* interval.
+	*
 	* @param options Options for the query.
 	* @returns An array of trace summaries.
 	*/
 	async getRecentTraces(options) {
-		const summaryPrefix = [...this.#keyPrefix, "_summaries"];
-		const summaries = [];
-		for await (const entry of this.#kv.list(summaryPrefix)) summaries.push(entry.value);
+		const aggregates = /* @__PURE__ */ new Map();
+		const traceIdIndex = this.#keyPrefix.length;
+		for await (const entry of this.#kv.list(this.#keyPrefix)) {
+			const traceId = entry.key[traceIdIndex];
+			if (traceId == null || traceId === "_summaries") continue;
+			const record = entry.value;
+			if (record == null || typeof record.timestamp !== "string") continue;
+			const aggregate = aggregates.get(traceId);
+			if (aggregate == null) aggregates.set(traceId, {
+				timestamp: record.timestamp,
+				activityCount: 1,
+				activityTypes: [record.activityType]
+			});
+			else {
+				aggregate.activityCount++;
+				if (record.timestamp < aggregate.timestamp) aggregate.timestamp = record.timestamp;
+				if (!aggregate.activityTypes.includes(record.activityType)) aggregate.activityTypes.push(record.activityType);
+			}
+		}
+		const summaries = [...aggregates].map(([traceId, aggregate]) => ({
+			traceId,
+			...aggregate
+		}));
 		summaries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 		if (options?.limit != null) return summaries.slice(0, options.limit);
 		return summaries;
@@ -506,6 +513,261 @@ test("FedifySpanExporter", async (t) => {
 		}
 		assertEquals((await exporter.getRecentTraces()).length >= 3, true);
 	});
+	function createOutboundSpan(traceId, spanId) {
+		return createMockSpan({
+			traceId,
+			spanId,
+			name: "activitypub.send_activity",
+			events: [createActivitySentEvent({
+				activityJson: JSON.stringify({
+					"@context": "https://www.w3.org/ns/activitystreams",
+					type: "Create",
+					id: `https://local.example/activities/${spanId}`
+				}),
+				inboxUrl: "https://follower.example/inbox"
+			})]
+		});
+	}
+	async function exportSpans(exporter, spans) {
+		assertEquals((await new Promise((resolve) => {
+			exporter.export(spans, resolve);
+		})).code, 0);
+	}
+	for (const withCas of [true, false]) {
+		const createStore = () => {
+			const memory = new MemoryKvStore();
+			return withCas ? memory : {
+				get: memory.get.bind(memory),
+				set: memory.set.bind(memory),
+				delete: memory.delete.bind(memory),
+				list: memory.list.bind(memory)
+			};
+		};
+		await t.step(`re-export counts each retained span once (CAS=${withCas})`, async () => {
+			const kv = createStore();
+			const exporters = [new FedifySpanExporter(kv), new FedifySpanExporter(kv)];
+			const span = createOutboundSpan("reexport-trace", "span-a");
+			await exportSpans(exporters[0], [span]);
+			await exportSpans(exporters[0], [span]);
+			assertEquals((await exporters[1].getRecentTraces())[0].activityCount, 1);
+			await Promise.all(exporters.map((exporter) => exportSpans(exporter, [span])));
+			assertEquals((await exporters[0].getActivitiesByTraceId("reexport-trace")).length, 1);
+			assertEquals((await exporters[1].getRecentTraces())[0].activityCount, 1);
+		});
+		await t.step(`concurrent distinct spans are all counted (CAS=${withCas})`, async () => {
+			const kv = createStore();
+			const exporters = [new FedifySpanExporter(kv), new FedifySpanExporter(kv)];
+			await Promise.all(exporters.map((exporter, i) => exportSpans(exporter, [createOutboundSpan("concurrent-count-trace", `span-${i}`)])));
+			const reader = new FedifySpanExporter(kv);
+			assertEquals((await reader.getActivitiesByTraceId("concurrent-count-trace")).length, 2);
+			assertEquals((await reader.getRecentTraces())[0].activityCount, 2);
+		});
+		await t.step(`legacy summaries cannot hide or inflate retained records (CAS=${withCas})`, async () => {
+			const kv = createStore();
+			const exporter = new FedifySpanExporter(kv);
+			await exportSpans(exporter, [createOutboundSpan("legacy-trace", "span-a")]);
+			await kv.delete([
+				"fedify",
+				"traces",
+				"_summaries",
+				"legacy-trace"
+			]);
+			const originalSet = kv.set.bind(kv);
+			let writes = 0;
+			kv.set = (...args) => {
+				writes++;
+				return originalSet(...args);
+			};
+			assertEquals((await exporter.getRecentTraces())[0].activityCount, 1);
+			assertEquals(writes, 0);
+			const stale = {
+				traceId: "legacy-trace",
+				timestamp: "2000-01-01T00:00:00.000Z",
+				activityCount: 99,
+				activityTypes: ["Bogus"]
+			};
+			await kv.set([
+				"fedify",
+				"traces",
+				"_summaries",
+				"legacy-trace"
+			], stale);
+			await kv.set([
+				"fedify",
+				"traces",
+				"_summaries",
+				"ghost-trace"
+			], {
+				...stale,
+				traceId: "ghost-trace"
+			});
+			const records = await exporter.getActivitiesByTraceId("legacy-trace");
+			assertEquals(await exporter.getRecentTraces(), [{
+				traceId: "legacy-trace",
+				timestamp: records[0].timestamp,
+				activityCount: 1,
+				activityTypes: ["Create"]
+			}]);
+			await kv.delete([
+				"fedify",
+				"traces",
+				"legacy-trace",
+				"span-a"
+			]);
+			assertEquals(await exporter.getRecentTraces(), []);
+		});
+		await t.step(`summary metadata follows retained records (CAS=${withCas})`, async () => {
+			const kv = createStore();
+			const exporter = new FedifySpanExporter(kv, { keyPrefix: ["custom"] });
+			function span(traceId, spanId, type, seconds) {
+				return createMockSpan({
+					traceId,
+					spanId,
+					events: [{
+						...createActivitySentEvent({
+							activityJson: JSON.stringify({ type }),
+							inboxUrl: "https://example.com/inbox"
+						}),
+						time: [seconds, 0]
+					}]
+				});
+			}
+			await exportSpans(exporter, [
+				span("older-trace", "late", "Like", 1700000002),
+				span("older-trace", "early", "Create", 17e8),
+				span("older-trace", "duplicate-type", "Like", 1700000003),
+				span("newer-trace", "only", "Follow", 1700000001)
+			]);
+			const recent = await exporter.getRecentTraces();
+			assertEquals(recent.map((summary) => summary.traceId), ["newer-trace", "older-trace"]);
+			assertEquals(recent[1], {
+				traceId: "older-trace",
+				timestamp: (/* @__PURE__ */ new Date(17e11)).toISOString(),
+				activityCount: 3,
+				activityTypes: ["Like", "Create"]
+			});
+			assertEquals(await exporter.getRecentTraces({ limit: 1 }), [recent[0]]);
+			await kv.delete([
+				"custom",
+				"older-trace",
+				"early"
+			]);
+			assertEquals((await exporter.getRecentTraces())[0], {
+				traceId: "older-trace",
+				timestamp: (/* @__PURE__ */ new Date(1700000002e3)).toISOString(),
+				activityCount: 2,
+				activityTypes: ["Like"]
+			});
+		});
+	}
+	await t.step("a trace with only one record is discoverable via getRecentTraces(), with no further write", async () => {
+		const exporter = new FedifySpanExporter(new MemoryKvStore());
+		const traceId = "first-write-discoverable-trace";
+		await new Promise((resolve) => {
+			exporter.export([createOutboundSpan(traceId, "span-a")], () => resolve());
+		});
+		assertEquals((await exporter.getRecentTraces()).find((s) => s.traceId === traceId)?.activityCount, 1);
+	});
+	await t.step("getRecentTraces() needs no additional writes to discover a trace or correct its activityCount", async () => {
+		const kv = new MemoryKvStore();
+		const exporter = new FedifySpanExporter(kv);
+		const traceId = "query-time-correction-trace";
+		await new Promise((resolve) => {
+			exporter.export([createOutboundSpan(traceId, "span-a")], () => resolve());
+		});
+		await new Promise((resolve) => {
+			exporter.export([createOutboundSpan(traceId, "span-b")], () => resolve());
+		});
+		const originalSet = kv.set.bind(kv);
+		let writeCalls = 0;
+		kv.set = (key, value, options) => {
+			writeCalls++;
+			return originalSet(key, value, options);
+		};
+		assertEquals((await exporter.getRecentTraces()).find((s) => s.traceId === traceId)?.activityCount, 2);
+		assertEquals(writeCalls, 0);
+	});
+	await t.step("getRecentTraces() reflects only currently-retained records, e.g., after some have expired", async () => {
+		const kv = new MemoryKvStore();
+		const exporter = new FedifySpanExporter(kv);
+		const traceId = "expiry-reflects-retained-trace";
+		await new Promise((resolve) => {
+			exporter.export([createOutboundSpan(traceId, "span-a"), createOutboundSpan(traceId, "span-b")], () => resolve());
+		});
+		let recent = await exporter.getRecentTraces();
+		assertEquals(recent.find((s) => s.traceId === traceId)?.activityCount, 2);
+		await kv.delete([
+			"fedify",
+			"traces",
+			traceId,
+			"span-a"
+		]);
+		recent = await exporter.getRecentTraces();
+		assertEquals(recent.find((s) => s.traceId === traceId)?.activityCount, 1);
+	});
+	await t.step("getRecentTraces() polling cost scales with every retained record, not just records changed since the last poll, and limit does not reduce it", async () => {
+		const kv = new MemoryKvStore();
+		const exporter = new FedifySpanExporter(kv);
+		const traceCount = 20;
+		const recordsPerTrace = 5;
+		for (let i = 0; i < traceCount; i++) {
+			const traceId = `poll-cost-trace-${i}`;
+			const spans = Array.from({ length: recordsPerTrace }, (_, j) => createOutboundSpan(traceId, `span-${j}`));
+			await new Promise((resolve) => {
+				exporter.export(spans, () => resolve());
+			});
+		}
+		const originalList = kv.list.bind(kv);
+		let entriesRead = 0;
+		let bytesRead = 0;
+		kv.list = async function* (prefix) {
+			for await (const entry of originalList(prefix)) {
+				entriesRead++;
+				bytesRead += new TextEncoder().encode(JSON.stringify(entry.value)).byteLength;
+				yield entry;
+			}
+		};
+		assertEquals((await exporter.getRecentTraces()).length, traceCount);
+		assertEquals(entriesRead, traceCount * recordsPerTrace);
+		assert(bytesRead > 0);
+		const entriesReadForFullScan = entriesRead;
+		const bytesReadForFullScan = bytesRead;
+		entriesRead = 0;
+		bytesRead = 0;
+		assertEquals((await exporter.getRecentTraces({ limit: 3 })).length, 3);
+		assertEquals(entriesRead, entriesReadForFullScan);
+		assertEquals(bytesRead, bytesReadForFullScan);
+	});
+	await t.step("recent-list scans include full inbound payloads even with limit", async () => {
+		const kv = new MemoryKvStore();
+		const exporter = new FedifySpanExporter(kv);
+		const activityJson = JSON.stringify({
+			type: "Create",
+			object: {
+				type: "Note",
+				content: "한".repeat(64 * 1024)
+			}
+		});
+		await exportSpans(exporter, Array.from({ length: 10 }, (_, i) => createMockSpan({
+			traceId: `large-inbound-${i}`,
+			spanId: "inbound",
+			events: [createActivityReceivedEvent({ activityJson })]
+		})));
+		const originalList = kv.list.bind(kv);
+		let entriesRead = 0;
+		let bytesRead = 0;
+		kv.list = async function* (prefix) {
+			for await (const entry of originalList(prefix)) {
+				entriesRead++;
+				bytesRead += new TextEncoder().encode(JSON.stringify(entry.value)).byteLength;
+				yield entry;
+			}
+		};
+		assertEquals((await exporter.getRecentTraces({ limit: 1 })).length, 1);
+		assertEquals(entriesRead, 10);
+		assert(bytesRead >= new TextEncoder().encode(activityJson).byteLength * 10);
+		assert(bytesRead > 1.8 * 1024 * 1024);
+	});
 	await t.step("forceFlush() returns resolved promise", async () => {
 		await new FedifySpanExporter(new MemoryKvStore()).forceFlush();
 	});

package/dist/otel/mod.cjs

@@ -189,33 +189,6 @@ var FedifySpanExporter = class {
 			record.spanId
 		];
 		await this.#kv.set(key, record, options);
-		await this.#updateTraceSummary(record, options);
-	}
-	async #setWithCasRetry(key, transform, options) {
-		if (this.#kv.cas != null) for (let attempt = 0; attempt < 3; attempt++) {
-			const existing = await this.#kv.get(key);
-			const newValue = transform(existing);
-			if (await this.#kv.cas(key, existing, newValue, options)) return;
-		}
-		const newValue = transform(await this.#kv.get(key));
-		await this.#kv.set(key, newValue, options);
-	}
-	async #updateTraceSummary(record, options) {
-		const summaryKey = [
-			...this.#keyPrefix,
-			"_summaries",
-			record.traceId
-		];
-		await this.#setWithCasRetry(summaryKey, (existing) => {
-			const activityCount = existing != null ? existing.activityCount + 1 : 1;
-			const activityTypes = existing != null ? existing.activityTypes.includes(record.activityType) ? existing.activityTypes : [...existing.activityTypes, record.activityType] : [record.activityType];
-			return {
-				traceId: existing?.traceId ?? record.traceId,
-				timestamp: existing?.timestamp ?? record.timestamp,
-				activityCount,
-				activityTypes
-			};
-		}, options);
 	}
 	/**
 	* Gets all activity records for a specific trace ID.
@@ -232,13 +205,46 @@ var FedifySpanExporter = class {
 	/**
 	* Gets recent traces with summary information.
 	*
+	* Each summary is computed directly from the activity records currently
+	* stored for each trace, rather than from a separately maintained
+	* counter.  This guarantees that a trace is discoverable, and its
+	* `activityCount` accurate, as soon as its records are stored, even if
+	* an earlier attempt at summarizing it (in a previous version of this
+	* exporter) never completed, and that the count always reflects
+	* records that have not expired.  It costs a full scan of every stored
+	* record on every call, including full inbound activity JSON.  The
+	* `limit` option only truncates the returned summaries and does not
+	* reduce the scan.  Callers that poll this method frequently should
+	* account for the total retained data when choosing a TTL and polling
+	* interval.
+	*
 	* @param options Options for the query.
 	* @returns An array of trace summaries.
 	*/
 	async getRecentTraces(options) {
-		const summaryPrefix = [...this.#keyPrefix, "_summaries"];
-		const summaries = [];
-		for await (const entry of this.#kv.list(summaryPrefix)) summaries.push(entry.value);
+		const aggregates = /* @__PURE__ */ new Map();
+		const traceIdIndex = this.#keyPrefix.length;
+		for await (const entry of this.#kv.list(this.#keyPrefix)) {
+			const traceId = entry.key[traceIdIndex];
+			if (traceId == null || traceId === "_summaries") continue;
+			const record = entry.value;
+			if (record == null || typeof record.timestamp !== "string") continue;
+			const aggregate = aggregates.get(traceId);
+			if (aggregate == null) aggregates.set(traceId, {
+				timestamp: record.timestamp,
+				activityCount: 1,
+				activityTypes: [record.activityType]
+			});
+			else {
+				aggregate.activityCount++;
+				if (record.timestamp < aggregate.timestamp) aggregate.timestamp = record.timestamp;
+				if (!aggregate.activityTypes.includes(record.activityType)) aggregate.activityTypes.push(record.activityType);
+			}
+		}
+		const summaries = [...aggregates].map(([traceId, aggregate]) => ({
+			traceId,
+			...aggregate
+		}));
 		summaries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 		if (options?.limit != null) return summaries.slice(0, options.limit);
 		return summaries;

package/dist/otel/mod.d.cts

@@ -225,6 +225,19 @@ declare class FedifySpanExporter implements SpanExporter {
   /**
   * Gets recent traces with summary information.
   *
+  * Each summary is computed directly from the activity records currently
+  * stored for each trace, rather than from a separately maintained
+  * counter.  This guarantees that a trace is discoverable, and its
+  * `activityCount` accurate, as soon as its records are stored, even if
+  * an earlier attempt at summarizing it (in a previous version of this
+  * exporter) never completed, and that the count always reflects
+  * records that have not expired.  It costs a full scan of every stored
+  * record on every call, including full inbound activity JSON.  The
+  * `limit` option only truncates the returned summaries and does not
+  * reduce the scan.  Callers that poll this method frequently should
+  * account for the total retained data when choosing a TTL and polling
+  * interval.
+  *
   * @param options Options for the query.
   * @returns An array of trace summaries.
   */

package/dist/otel/mod.d.ts

@@ -225,6 +225,19 @@ declare class FedifySpanExporter implements SpanExporter {
   /**
   * Gets recent traces with summary information.
   *
+  * Each summary is computed directly from the activity records currently
+  * stored for each trace, rather than from a separately maintained
+  * counter.  This guarantees that a trace is discoverable, and its
+  * `activityCount` accurate, as soon as its records are stored, even if
+  * an earlier attempt at summarizing it (in a previous version of this
+  * exporter) never completed, and that the count always reflects
+  * records that have not expired.  It costs a full scan of every stored
+  * record on every call, including full inbound activity JSON.  The
+  * `limit` option only truncates the returned summaries and does not
+  * reduce the scan.  Callers that poll this method frequently should
+  * account for the total retained data when choosing a TTL and polling
+  * interval.
+  *
   * @param options Options for the query.
   * @returns An array of trace summaries.
   */

package/dist/otel/mod.js

@@ -187,33 +187,6 @@ var FedifySpanExporter = class {
 			record.spanId
 		];
 		await this.#kv.set(key, record, options);
-		await this.#updateTraceSummary(record, options);
-	}
-	async #setWithCasRetry(key, transform, options) {
-		if (this.#kv.cas != null) for (let attempt = 0; attempt < 3; attempt++) {
-			const existing = await this.#kv.get(key);
-			const newValue = transform(existing);
-			if (await this.#kv.cas(key, existing, newValue, options)) return;
-		}
-		const newValue = transform(await this.#kv.get(key));
-		await this.#kv.set(key, newValue, options);
-	}
-	async #updateTraceSummary(record, options) {
-		const summaryKey = [
-			...this.#keyPrefix,
-			"_summaries",
-			record.traceId
-		];
-		await this.#setWithCasRetry(summaryKey, (existing) => {
-			const activityCount = existing != null ? existing.activityCount + 1 : 1;
-			const activityTypes = existing != null ? existing.activityTypes.includes(record.activityType) ? existing.activityTypes : [...existing.activityTypes, record.activityType] : [record.activityType];
-			return {
-				traceId: existing?.traceId ?? record.traceId,
-				timestamp: existing?.timestamp ?? record.timestamp,
-				activityCount,
-				activityTypes
-			};
-		}, options);
 	}
 	/**
 	* Gets all activity records for a specific trace ID.
@@ -230,13 +203,46 @@ var FedifySpanExporter = class {
 	/**
 	* Gets recent traces with summary information.
 	*
+	* Each summary is computed directly from the activity records currently
+	* stored for each trace, rather than from a separately maintained
+	* counter.  This guarantees that a trace is discoverable, and its
+	* `activityCount` accurate, as soon as its records are stored, even if
+	* an earlier attempt at summarizing it (in a previous version of this
+	* exporter) never completed, and that the count always reflects
+	* records that have not expired.  It costs a full scan of every stored
+	* record on every call, including full inbound activity JSON.  The
+	* `limit` option only truncates the returned summaries and does not
+	* reduce the scan.  Callers that poll this method frequently should
+	* account for the total retained data when choosing a TTL and polling
+	* interval.
+	*
 	* @param options Options for the query.
 	* @returns An array of trace summaries.
 	*/
 	async getRecentTraces(options) {
-		const summaryPrefix = [...this.#keyPrefix, "_summaries"];
-		const summaries = [];
-		for await (const entry of this.#kv.list(summaryPrefix)) summaries.push(entry.value);
+		const aggregates = /* @__PURE__ */ new Map();
+		const traceIdIndex = this.#keyPrefix.length;
+		for await (const entry of this.#kv.list(this.#keyPrefix)) {
+			const traceId = entry.key[traceIdIndex];
+			if (traceId == null || traceId === "_summaries") continue;
+			const record = entry.value;
+			if (record == null || typeof record.timestamp !== "string") continue;
+			const aggregate = aggregates.get(traceId);
+			if (aggregate == null) aggregates.set(traceId, {
+				timestamp: record.timestamp,
+				activityCount: 1,
+				activityTypes: [record.activityType]
+			});
+			else {
+				aggregate.activityCount++;
+				if (record.timestamp < aggregate.timestamp) aggregate.timestamp = record.timestamp;
+				if (!aggregate.activityTypes.includes(record.activityType)) aggregate.activityTypes.push(record.activityType);
+			}
+		}
+		const summaries = [...aggregates].map(([traceId, aggregate]) => ({
+			traceId,
+			...aggregate
+		}));
 		summaries.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
 		if (options?.limit != null) return summaries.slice(0, options.limit);
 		return summaries;

package/dist/{owner-BUTMEkbn.mjs → owner-B8kXzD0q.mjs}

@@ -1,8 +1,8 @@
 import "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-JUTr6LYC.mjs";
-import { c as verifyKeyOwnership, n as fetchActorDocument, t as exportJwk } from "./key-D0ahOVjf.mjs";
+import { n as version, t as name } from "./deno-BUj4roJc.mjs";
+import { c as verifyKeyOwnership, n as fetchActorDocument, t as exportJwk } from "./key-C3o3DGap.mjs";
 import { CryptographicKey, Object as Object$1, isActor } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { getDocumentLoader } from "@fedify/vocab-runtime";

package/dist/{proof-DS1Zl6BX.mjs → proof-CBQOjOgA.mjs}

@@ -1,8 +1,8 @@
 import { Temporal } from "@js-temporal/polyfill";
 import "urlpattern-polyfill";
 globalThis.addEventListener = () => {};
-import { n as version, t as name } from "./deno-JUTr6LYC.mjs";
-import { r as fetchKey, s as validateCryptoKey } from "./key-D0ahOVjf.mjs";
+import { n as version, t as name } from "./deno-BUj4roJc.mjs";
+import { r as fetchKey, s as validateCryptoKey } from "./key-C3o3DGap.mjs";
 import { n as preloadedOnlyDocumentLoader } from "./public-audience-DpJqzPuh.mjs";
 import { r as normalizeOutgoingActivityJsonLd } from "./outgoing-jsonld-amccRMrV.mjs";
 import { Activity, DataIntegrityProof, Multikey, getTypeId } from "@fedify/vocab";

package/dist/{proof-Bm3xyn3D.js → proof-DKX6nASL.js}

@@ -1,6 +1,6 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { URLPattern } from "urlpattern-polyfill";
-import { c as fetchKey, f as validateCryptoKey, o as exportJwk, p as verifyKeyOwnership, s as fetchActorDocument, v as name, y as version } from "./http-OSYYhKM8.js";
+import { c as fetchKey, f as validateCryptoKey, o as exportJwk, p as verifyKeyOwnership, s as fetchActorDocument, v as name, y as version } from "./http-C5g_VrA_.js";
 import { getLogger } from "@logtape/logtape";
 import { Activity, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1, PUBLIC_COLLECTION, getTypeId, isActor } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";

package/dist/{proof-BeY7TsiS.cjs → proof-qiuGJCD7.cjs}

@@ -1,7 +1,7 @@
 const { Temporal } = require("@js-temporal/polyfill");
 const { URLPattern } = require("urlpattern-polyfill");
 const require_chunk = require("./chunk-DDcVe30Y.cjs");
-const require_http = require("./http-DEH_eppX.cjs");
+const require_http = require("./http-D8I7LBfx.cjs");
 let _logtape_logtape = require("@logtape/logtape");
 let _fedify_vocab = require("@fedify/vocab");
 let _opentelemetry_api = require("@opentelemetry/api");