@fedify/fedify 2.5.0-dev.2448 → 2.5.0-dev.2492

package/dist/sig/http.test.mjs

@@ -12,12 +12,14 @@ import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { x as exportJwk } from "../ld-CQFuiah9.mjs";
-import { a as listRequestSignatures, c as selectRequestSignature, f as verifyRequest, i as formatRfc9421SignatureParameters, l as signRequest, n as doubleKnock, o as parseRfc9421Signature, p as verifyRequestDetailed, r as formatRfc9421Signature, s as parseRfc9421SignatureInput, t as createRfc9421SignatureBase, u as timingSafeEqual } from "../http-BZkyQIkb.mjs";
+import { x as exportJwk } from "../ld-CdvcOEXQ.mjs";
+import { a as formatRfc9421SignatureParameters, c as parseRfc9421SignatureInput, d as timingSafeEqual, i as formatRfc9421Signature, l as selectRequestSignature, m as verifyRequestDetailed, n as doubleKnock, o as listRequestSignatures, p as verifyRequest, r as doubleKnockScoped, s as parseRfc9421Signature, t as createRfc9421SignatureBase, u as signRequest } from "../http-BoJCMnjY.mjs";
 import { a as rsaPrivateKey3, i as rsaPrivateKey2, l as rsaPublicKey5, n as ed25519PrivateKey, o as rsaPublicKey1, r as ed25519PublicKey, s as rsaPublicKey2 } from "../keys-DIJNHW-Y.mjs";
 import { t as KvKeyCache } from "../keycache-N2opu4-3.mjs";
+import { configure, reset } from "@logtape/logtape";
 import { FetchError, UrlError, exportSpki, getDocumentLoader } from "@fedify/vocab-runtime";
 import { createTestMeterProvider, createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
+import { openDirectFetch } from "@fedify/vocab-runtime/internal";
 import { encodeBase64 } from "byte-encodings/base64";
 //#region ../../node_modules/.pnpm/@jsr+std__assert@0.226.0/node_modules/@jsr/std__assert/assert_string_includes.js
 /**
@@ -1878,6 +1880,472 @@ test("doubleKnock() async specDeterminer test", async () => {
 	assertEquals(specUsed, "draft-cavage-http-signatures-12", "Should use spec from async determiner");
 	esm_default.hardReset();
 });
+const lifecycleIdentity = {
+	keyId: rsaPublicKey2.id,
+	privateKey: rsaPrivateKey2
+};
+test("doubleKnockScoped() keeps challenge retries and fallback in the validated hop", async () => {
+	const url = "https://example.com/lifecycle/challenge-fallback";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");nonce=\"challenge-nonce\"" },
+		body: "Challenge"
+	} : index === 2 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : {
+		status: 202,
+		body: "Accepted"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Accepted");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`fetch #3 ${url}`,
+		"consumed #3",
+		`close ${url}`
+	]);
+	assertStringIncludes(hops.requests[1].headers.get("Signature-Input"), "nonce=\"challenge-nonce\"");
+	assertFalse(hops.requests[2].headers.has("Signature-Input"));
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() reopens the session after challenge redirects", async () => {
+	const url = "https://example.com/lifecycle/challenge-redirect";
+	const next = "https://other.example/lifecycle/final";
+	const validated = [];
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");created" },
+		body: "Challenge"
+	} : index === 2 ? {
+		status: 307,
+		headers: { Location: next },
+		body: "Redirect"
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, { validateRedirect: (target) => {
+		validated.push(target);
+	} }, hops.openHop, (response) => response.text()), "Done");
+	assertEquals(validated, [next]);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"consumed #3",
+		`close ${next}`
+	]);
+	assertEquals(await hops.requests[2].text(), "activity");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() preserves maxRedirection across challenge redirects", async (t) => {
+	for (const maxRedirection of [0, 1]) await t.step(`limit ${maxRedirection}`, async () => {
+		const url = "https://example.com/lifecycle/challenge-limit";
+		const hops = recordHops((request, index) => index % 2 === 1 ? {
+			status: 401,
+			headers: { "Accept-Signature": "challenge=(\"@method\");created" },
+			body: "Challenge"
+		} : {
+			status: 307,
+			headers: { Location: `${request.url}/next` },
+			body: "Redirect"
+		});
+		await assertRejects(() => doubleKnockScoped(new Request(url, {
+			method: "POST",
+			body: "activity"
+		}), lifecycleIdentity, { maxRedirection }, hops.openHop, (response) => response.text()), FetchError, `Too many redirections (${maxRedirection + 1})`);
+		assertEquals(hops.requests.length, 2 * (maxRedirection + 1));
+		assertEquals(hops.events.filter((event) => event.startsWith("open ")).length, maxRedirection + 1);
+		assertEquals(hops.events.filter((event) => event.startsWith("cancel #")).length, hops.requests.length);
+		hops.assertInvariants();
+	});
+});
+test("doubleKnockScoped() detects loops after challenge redirects", async () => {
+	const url = "https://example.com/lifecycle/challenge-loop";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");created" },
+		body: "Challenge"
+	} : {
+		status: 307,
+		headers: { Location: url },
+		body: "Redirect"
+	});
+	await assertRejects(() => doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), FetchError, "Redirect loop detected");
+	assertEquals(hops.requests.length, 2);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`
+	]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() closes the session when aborted while determining the spec", async () => {
+	const url = "https://example.com/lifecycle/aborted-spec";
+	const hops = recordHops(() => ({
+		status: 202,
+		body: "Accepted"
+	}));
+	const controller = new AbortController();
+	const reason = /* @__PURE__ */ new Error("spec determination aborted");
+	assertEquals(await assertRejects(() => doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {
+		signal: controller.signal,
+		specDeterminer: {
+			determineSpec() {
+				controller.abort(reason);
+				return Promise.resolve("rfc9421");
+			},
+			rememberSpec: () => Promise.resolve()
+		}
+	}, hops.openHop, (response) => response.text()), Error, "spec determination aborted"), reason);
+	assertEquals(hops.events, [`open ${url}`, `close ${url}`]);
+	assertEquals(hops.requests, []);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() retries another spec on the same hop", async () => {
+	const url = "https://example.com/lifecycle/retry";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : {
+		status: 202,
+		body: "Accepted"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Accepted");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"consumed #2",
+		`close ${url}`
+	]);
+	assertEquals(hops.requests.map((r) => r.headers.has("Signature-Input")), [true, false]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() closes the retried hop before a redirect", async () => {
+	const url = "https://example.com/lifecycle/retry-redirect";
+	const next = "https://example.com/lifecycle/final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : index === 2 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found"
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Done");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"consumed #3",
+		`close ${next}`
+	]);
+	assertEquals(await hops.requests[2].text(), "activity");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() retries transport errors on the same hop", async (t) => {
+	await t.step("GET", async () => {
+		const url = "https://example.com/lifecycle/flaky";
+		const hops = recordHops((_, index) => {
+			if (index === 1) throw new TypeError("connection reset");
+			return { body: "Success" };
+		});
+		assertEquals(await doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Success");
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			`fetch #2 ${url}`,
+			"consumed #2",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+	await t.step("POST", async () => {
+		const url = "https://example.com/lifecycle/flaky-inbox";
+		const hops = recordHops(() => {
+			throw new TypeError("connection reset");
+		});
+		await assertRejects(() => doubleKnockScoped(new Request(url, {
+			method: "POST",
+			body: "activity"
+		}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), FetchError);
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+});
+async function captureLogs(fn) {
+	const records = [];
+	await configure({
+		sinks: { buffer: (record) => records.push(record) },
+		loggers: [{
+			category: "fedify",
+			sinks: ["buffer"],
+			lowestLevel: "debug"
+		}, {
+			category: ["logtape", "meta"],
+			sinks: []
+		}],
+		reset: true
+	});
+	try {
+		await fn();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	} finally {
+		await reset();
+	}
+	return records;
+}
+test("doubleKnockScoped() logs a redirect body failing to cancel and follows the redirect", async () => {
+	const url = "https://example.com/lifecycle/cancel-failure";
+	const next = "https://example.com/lifecycle/cancel-failure-final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found",
+		failCancel: true
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	let result;
+	const records = await captureLogs(async () => {
+		result = await doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, (response) => response.text());
+	});
+	assertEquals(result, "Done");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #2 ${next}`,
+		"consumed #2",
+		`close ${next}`
+	]);
+	const failures = records.filter((r) => r.rawMessage === "Failed to cancel the response body from {url}: {error}");
+	assertEquals(failures.map((r) => [r.level, r.properties.url]), [["debug", url]]);
+	assertEquals(failures[0].properties.error.message, "cancel #1 failed");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() is not blocked by a body cancellation that never settles", async () => {
+	const url = "https://example.com/lifecycle/hanging-cancel";
+	const next = "https://example.com/lifecycle/hanging-cancel-final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized",
+		hangCancel: true
+	} : index === 2 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found",
+		hangCancel: true
+	} : {
+		status: 200,
+		body: "Done",
+		hangCancel: true
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => Promise.resolve(response.status)), 200);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"cancel #3 by close",
+		`close ${next}`
+	]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() completes with responses cloned by fetch-mock", async () => {
+	esm_default.spyGlobal();
+	try {
+		let attempts = 0;
+		esm_default.post("https://example.com/tee/redirect", () => {
+			attempts++;
+			return attempts === 1 ? new Response("Unauthorized", { status: 401 }) : new Response("Found", {
+				status: 302,
+				headers: { Location: "https://example.com/tee/final" }
+			});
+		});
+		esm_default.post("https://example.com/tee/final", () => new Response("Accepted", { status: 202 }));
+		const request = () => new Request("https://example.com/tee/redirect", {
+			method: "POST",
+			body: "activity"
+		});
+		assertEquals(await doubleKnockScoped(request(), lifecycleIdentity, {}, openDirectFetch, (response) => Promise.resolve(response.status)), 202);
+		assertEquals(attempts, 2);
+		attempts = 0;
+		const response = await doubleKnock(request(), lifecycleIdentity);
+		assertEquals(response.status, 202);
+		assertEquals(await response.text(), "Accepted");
+		assertEquals(attempts, 2);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+test("doubleKnockScoped() closes the session when consuming fails", async (t) => {
+	const url = "https://example.com/lifecycle/consume";
+	await t.step("exception", async () => {
+		const hops = recordHops(() => ({ body: "x".repeat(1024) }));
+		const error = /* @__PURE__ */ new Error("consume failed");
+		await assertRejects(() => doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, async (response) => {
+			const reader = response.body.getReader();
+			await reader.read();
+			reader.releaseLock();
+			throw error;
+		}), Error, "consume failed");
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			"cancel #1 by close",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+	await t.step("abort", async () => {
+		const hops = recordHops(() => ({ body: "Success" }));
+		const controller = new AbortController();
+		const reason = /* @__PURE__ */ new Error("aborted while consuming");
+		assert(await assertRejects(() => doubleKnockScoped(new Request(url), lifecycleIdentity, { signal: controller.signal }, hops.openHop, () => {
+			controller.abort(reason);
+			controller.signal.throwIfAborted();
+			return Promise.resolve();
+		})) === reason);
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			"cancel #1 by close",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+});
+test("doubleKnock() returns the final response without cancelling its body", async () => {
+	const url = "https://example.com/lifecycle/public";
+	const next = "https://example.com/lifecycle/public-final";
+	const events = [];
+	const responses = [];
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = ((input) => {
+		const requestUrl = input instanceof Request ? input.url : String(input);
+		const index = responses.length + 1;
+		events.push(`fetch #${index} ${requestUrl}`);
+		const recorded = createRecordedResponse(events, index, requestUrl === url ? {
+			status: 302,
+			headers: { Location: next },
+			body: "Found"
+		} : {
+			status: 200,
+			body: "Done"
+		});
+		responses.push(recorded);
+		return Promise.resolve(recorded.response);
+	});
+	try {
+		const response = await doubleKnock(new Request(url), lifecycleIdentity);
+		assertEquals(events, [
+			`fetch #1 ${url}`,
+			"cancel #1",
+			`fetch #2 ${next}`
+		]);
+		assertFalse(responses[1].settled());
+		assertEquals(await response.text(), "Done");
+		assertEquals(events.at(-1), "consumed #2");
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+test("doubleKnock() is not blocked by a body cancellation that never settles", async () => {
+	const url = "https://example.com/lifecycle/public-hanging";
+	const next = "https://example.com/lifecycle/public-hanging-final";
+	const events = [];
+	const originalFetch = globalThis.fetch;
+	let index = 0;
+	globalThis.fetch = ((input) => {
+		const requestUrl = input instanceof Request ? input.url : String(input);
+		index++;
+		events.push(`fetch #${index} ${requestUrl}`);
+		return Promise.resolve(createRecordedResponse(events, index, index === 1 ? {
+			status: 401,
+			body: "Unauthorized",
+			hangCancel: true
+		} : index === 2 ? {
+			status: 302,
+			headers: { Location: next },
+			body: "Found",
+			hangCancel: true
+		} : {
+			status: 200,
+			body: "Done"
+		}).response);
+	});
+	try {
+		const response = await doubleKnock(new Request(url, {
+			method: "POST",
+			body: "activity"
+		}), lifecycleIdentity);
+		assertEquals(events, [
+			`fetch #1 ${url}`,
+			"cancel #1",
+			`fetch #2 ${url}`,
+			"cancel #2",
+			`fetch #3 ${next}`
+		]);
+		assertEquals(await response.text(), "Done");
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
 test("timingSafeEqual()", async (t) => {
 	await t.step("should return true for equal empty arrays", () => {
 		assert(timingSafeEqual(new Uint8Array([]), new Uint8Array([])));
@@ -2737,5 +3205,88 @@ test("verifyRequestDetailed() reports a timed-out key fetch", async (t) => {
 		}
 	});
 });
+function createRecordedResponse(events, index, init, cancelSuffix = () => "") {
+	const bytes = new TextEncoder().encode(init.body ?? "");
+	const chunkSize = init.chunkSize ?? 256;
+	let offset = 0;
+	let settled = false;
+	const body = new ReadableStream({
+		pull(controller) {
+			if (offset >= bytes.length) {
+				settled = true;
+				events.push(`consumed #${index}`);
+				controller.close();
+				return;
+			}
+			controller.enqueue(bytes.slice(offset, offset + chunkSize));
+			offset += chunkSize;
+		},
+		cancel() {
+			settled = true;
+			events.push(`cancel #${index}${cancelSuffix()}`);
+			if (init.failCancel) throw new Error(`cancel #${index} failed`);
+			if (init.hangCancel) return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	return {
+		response: new Response(body, {
+			status: init.status ?? 200,
+			headers: init.headers
+		}),
+		settled: () => settled
+	};
+}
+function recordHops(respond) {
+	const events = [];
+	const requests = [];
+	const unsettledAtClose = [];
+	let opens = 0;
+	let closes = 0;
+	let fetches = 0;
+	return {
+		events,
+		requests,
+		openHop(url) {
+			opens++;
+			events.push(`open ${url}`);
+			const tracked = [];
+			let closed = false;
+			let closing = false;
+			return Promise.resolve({
+				url: new URL(url),
+				async fetch(input, init) {
+					if (closed) throw new TypeError("The session is closed.");
+					const request = new Request(input instanceof Request ? input.clone() : input, init);
+					const index = ++fetches;
+					requests.push(request);
+					events.push(`fetch #${index} ${request.url}`);
+					const recorded = createRecordedResponse(events, index, await respond(request, index), () => closing ? " by close" : "");
+					tracked.push({
+						...recorded,
+						index
+					});
+					return recorded.response;
+				},
+				close() {
+					if (closed) return Promise.resolve();
+					closed = true;
+					closes++;
+					closing = true;
+					for (const { response, settled, index } of tracked) {
+						if (settled()) continue;
+						if (response.body?.locked) unsettledAtClose.push(index);
+						else response.body?.cancel().catch(() => {});
+					}
+					events.push(`close ${url}`);
+					return Promise.resolve();
+				}
+			});
+		},
+		assertInvariants() {
+			assertEquals(opens, closes);
+			assertEquals(unsettledAtClose, []);
+		}
+	};
+}
 //#endregion
 export {};

package/dist/sig/key.test.mjs

@@ -8,7 +8,7 @@ import "../std__assert-DvMDRPes.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assertStrictEquals } from "../assert_strict_equals-CYvBmkpC.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { C as fetchKey, D as validateCryptoKey, E as importJwk, T as generateCryptoKeyPair, w as fetchKeyDetailed, x as exportJwk, y as wrapContextLoaderForJsonLd } from "../ld-CQFuiah9.mjs";
+import { C as fetchKey, D as validateCryptoKey, E as importJwk, T as generateCryptoKeyPair, w as fetchKeyDetailed, x as exportJwk, y as wrapContextLoaderForJsonLd } from "../ld-CdvcOEXQ.mjs";
 import { c as rsaPublicKey3, i as rsaPrivateKey2, o as rsaPublicKey1, r as ed25519PublicKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
 import { CryptographicKey, Multikey, Person } from "@fedify/vocab";
 import { FetchError, UrlError, exportDidKey, getDocumentLoader } from "@fedify/vocab-runtime";

package/dist/sig/ld.test.mjs

@@ -8,7 +8,7 @@ import { t as assertInstanceOf } from "../assert_instance_of-mrXWWNY-.mjs";
 import { t as assertThrows } from "../assert_throws-BYITOvPO.mjs";
 import { t as assertRejects } from "../assert_rejects-CTptdYck.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { T as generateCryptoKeyPair, _ as verifyJsonLd, a as compactJsonLd, f as isInvalidUrlTypeError, i as attachSignature, m as signJsonLd, n as UnsafeJsonLdError, o as createSignature, s as detachSignature, u as hasSignatureLike, v as verifySignature } from "../ld-CQFuiah9.mjs";
+import { T as generateCryptoKeyPair, _ as verifyJsonLd, a as compactJsonLd, f as isInvalidUrlTypeError, i as attachSignature, m as signJsonLd, n as UnsafeJsonLdError, o as createSignature, s as detachSignature, u as hasSignatureLike, v as verifySignature } from "../ld-CdvcOEXQ.mjs";
 import { a as rsaPrivateKey3, c as rsaPublicKey3, i as rsaPrivateKey2, n as ed25519PrivateKey, s as rsaPublicKey2, t as ed25519Multikey } from "../keys-DIJNHW-Y.mjs";
 import { CryptographicKey } from "@fedify/vocab";
 import { createTestMeterProvider, mockDocumentLoader, test } from "@fedify/fixture";

package/dist/sig/mitra-receive-interop.test.mjs

@@ -5,10 +5,10 @@ import { t as MemoryKvStore } from "../kv-DCHkaJ9-.mjs";
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { d as verifyPortableObjectProof } from "../proof-DPoF06nz.mjs";
-import { p as verifyRequestDetailed } from "../http-BZkyQIkb.mjs";
-import { o as createFederation } from "../middleware-CuVa0UuS.mjs";
-import { t as doesActorOwnKey } from "../owner-ccKkQOAf.mjs";
+import { d as verifyPortableObjectProof } from "../proof-GH7Poos_.mjs";
+import { m as verifyRequestDetailed } from "../http-BoJCMnjY.mjs";
+import { o as createFederation } from "../middleware-CoBLrTKX.mjs";
+import { t as doesActorOwnKey } from "../owner-DTnVpUKA.mjs";
 import { Create, Person } from "@fedify/vocab";
 import { canonicalizePortableUri, decodeMultibase, importDidKey } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/sig/mitra-send-interop.test.mjs

@@ -4,9 +4,9 @@ globalThis.addEventListener = () => {};
 import { t as assertEquals } from "../assert_equals-Z6IcEbWU.mjs";
 import "../std__assert-DvMDRPes.mjs";
 import { t as assert } from "../assert-D1Eafmd_.mjs";
-import { d as verifyPortableObjectProof } from "../proof-DPoF06nz.mjs";
-import { p as verifyRequestDetailed } from "../http-BZkyQIkb.mjs";
-import { t as doesActorOwnKey } from "../owner-ccKkQOAf.mjs";
+import { d as verifyPortableObjectProof } from "../proof-GH7Poos_.mjs";
+import { m as verifyRequestDetailed } from "../http-BoJCMnjY.mjs";
+import { t as doesActorOwnKey } from "../owner-DTnVpUKA.mjs";
 import { Create } from "@fedify/vocab";
 import { canonicalizePortableUri, decodeMultibase, fromCompatibleEf61Id, importDidKey } from "@fedify/vocab-runtime";
 import { mockDocumentLoader, test } from "@fedify/fixture";

package/dist/sig/mod.cjs

@@ -1,7 +1,7 @@
 const { URLPattern } = require("urlpattern-polyfill");
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_http = require("../http-CAl7Num5.cjs");
-const require_portable_collection = require("../portable-collection-TC-kvkVI.cjs");
+const require_http = require("../http-kv1LZw-r.cjs");
+const require_portable_collection = require("../portable-collection-DciwBIia.cjs");
 exports.attachSignature = require_http.attachSignature;
 exports.createProof = require_http.createProof;
 exports.createSignature = require_http.createSignature;

package/dist/sig/mod.d.cts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { A as AcceptSignatureParameters, B as VerifyPortableObjectProofOptions, C as VerifyRequestDetailedResult, D as verifyRequest, E as signRequest, F as validateAcceptSignature, G as signObject, H as VerifyProofOptions, I as CreateProofOptions, J as verifyProof, K as verifyObject, L as SignObjectOptions, M as formatAcceptSignature, N as fulfillAcceptSignature, O as verifyRequestDetailed, P as parseAcceptSignature, R as VerifyObjectOptions, S as SignRequestOptions, T as VerifyRequestOptions, U as createProof, V as VerifyPortableObjectProofResult, W as hasProofLike, a as KeyCache, b as HttpMessageSignaturesSpecDeterminer, c as fetchKeyDetailed, i as FetchKeyResult, j as FulfillAcceptSignatureResult, k as AcceptSignatureMember, l as generateCryptoKeyPair, n as FetchKeyErrorResult, o as exportJwk, q as verifyPortableObjectProof, r as FetchKeyOptions, s as fetchKey, t as FetchKeyDetailedResult, u as importJwk, w as VerifyRequestFailureReason, x as Rfc9421SignRequestOptions, y as HttpMessageSignaturesSpec, z as VerifyPortableObjectProofFailureReason } from "../key-nYGY4QB9.cjs";
-import { a as VerifySignatureOptions, c as detachSignature, d as verifyJsonLd, f as verifySignature, g as getKeyOwner, h as doesActorOwnKey, i as VerifyJsonLdOptions, l as hasSignatureLike, m as GetKeyOwnerOptions, o as attachSignature, p as DoesActorOwnKeyOptions, r as SignJsonLdOptions, s as createSignature, t as CreateSignatureOptions, u as signJsonLd } from "../ld-Cel1RRZ5.cjs";
-import { i as verifyPortableObject, n as VerifyPortableObjectOptions, r as VerifyPortableObjectResult, t as VerifyPortableObjectFailureReason } from "../mod-B2783_3v.cjs";
+import { A as AcceptSignatureParameters, B as VerifyPortableObjectProofOptions, C as VerifyRequestDetailedResult, D as verifyRequest, E as signRequest, F as validateAcceptSignature, G as signObject, H as VerifyProofOptions, I as CreateProofOptions, J as verifyProof, K as verifyObject, L as SignObjectOptions, M as formatAcceptSignature, N as fulfillAcceptSignature, O as verifyRequestDetailed, P as parseAcceptSignature, R as VerifyObjectOptions, S as SignRequestOptions, T as VerifyRequestOptions, U as createProof, V as VerifyPortableObjectProofResult, W as hasProofLike, a as KeyCache, b as HttpMessageSignaturesSpecDeterminer, c as fetchKeyDetailed, i as FetchKeyResult, j as FulfillAcceptSignatureResult, k as AcceptSignatureMember, l as generateCryptoKeyPair, n as FetchKeyErrorResult, o as exportJwk, q as verifyPortableObjectProof, r as FetchKeyOptions, s as fetchKey, t as FetchKeyDetailedResult, u as importJwk, w as VerifyRequestFailureReason, x as Rfc9421SignRequestOptions, y as HttpMessageSignaturesSpec, z as VerifyPortableObjectProofFailureReason } from "../key-DlHT4R6k.cjs";
+import { a as VerifySignatureOptions, c as detachSignature, d as verifyJsonLd, f as verifySignature, g as getKeyOwner, h as doesActorOwnKey, i as VerifyJsonLdOptions, l as hasSignatureLike, m as GetKeyOwnerOptions, o as attachSignature, p as DoesActorOwnKeyOptions, r as SignJsonLdOptions, s as createSignature, t as CreateSignatureOptions, u as signJsonLd } from "../ld-CWVpo_NM.cjs";
+import { i as verifyPortableObject, n as VerifyPortableObjectOptions, r as VerifyPortableObjectResult, t as VerifyPortableObjectFailureReason } from "../mod-C1nT74IG.cjs";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyPortableObjectFailureReason, VerifyPortableObjectOptions, VerifyPortableObjectProofFailureReason, VerifyPortableObjectProofOptions, VerifyPortableObjectProofResult, VerifyPortableObjectResult, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyPortableObject, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };

package/dist/sig/mod.d.ts

@@ -1,5 +1,5 @@
 /// <reference lib="esnext.temporal" />
-import { A as AcceptSignatureParameters, B as VerifyPortableObjectProofOptions, C as VerifyRequestDetailedResult, D as verifyRequest, E as signRequest, F as validateAcceptSignature, G as signObject, H as VerifyProofOptions, I as CreateProofOptions, J as verifyProof, K as verifyObject, L as SignObjectOptions, M as formatAcceptSignature, N as fulfillAcceptSignature, O as verifyRequestDetailed, P as parseAcceptSignature, R as VerifyObjectOptions, S as SignRequestOptions, T as VerifyRequestOptions, U as createProof, V as VerifyPortableObjectProofResult, W as hasProofLike, a as KeyCache, b as HttpMessageSignaturesSpecDeterminer, c as fetchKeyDetailed, i as FetchKeyResult, j as FulfillAcceptSignatureResult, k as AcceptSignatureMember, l as generateCryptoKeyPair, n as FetchKeyErrorResult, o as exportJwk, q as verifyPortableObjectProof, r as FetchKeyOptions, s as fetchKey, t as FetchKeyDetailedResult, u as importJwk, w as VerifyRequestFailureReason, x as Rfc9421SignRequestOptions, y as HttpMessageSignaturesSpec, z as VerifyPortableObjectProofFailureReason } from "../key-DhsBxxZN.js";
-import { a as VerifySignatureOptions, c as detachSignature, d as verifyJsonLd, f as verifySignature, g as getKeyOwner, h as doesActorOwnKey, i as VerifyJsonLdOptions, l as hasSignatureLike, m as GetKeyOwnerOptions, o as attachSignature, p as DoesActorOwnKeyOptions, r as SignJsonLdOptions, s as createSignature, t as CreateSignatureOptions, u as signJsonLd } from "../ld-CcuZ4NZa.js";
-import { i as verifyPortableObject, n as VerifyPortableObjectOptions, r as VerifyPortableObjectResult, t as VerifyPortableObjectFailureReason } from "../mod-BHQE-7WQ.js";
+import { A as AcceptSignatureParameters, B as VerifyPortableObjectProofOptions, C as VerifyRequestDetailedResult, D as verifyRequest, E as signRequest, F as validateAcceptSignature, G as signObject, H as VerifyProofOptions, I as CreateProofOptions, J as verifyProof, K as verifyObject, L as SignObjectOptions, M as formatAcceptSignature, N as fulfillAcceptSignature, O as verifyRequestDetailed, P as parseAcceptSignature, R as VerifyObjectOptions, S as SignRequestOptions, T as VerifyRequestOptions, U as createProof, V as VerifyPortableObjectProofResult, W as hasProofLike, a as KeyCache, b as HttpMessageSignaturesSpecDeterminer, c as fetchKeyDetailed, i as FetchKeyResult, j as FulfillAcceptSignatureResult, k as AcceptSignatureMember, l as generateCryptoKeyPair, n as FetchKeyErrorResult, o as exportJwk, q as verifyPortableObjectProof, r as FetchKeyOptions, s as fetchKey, t as FetchKeyDetailedResult, u as importJwk, w as VerifyRequestFailureReason, x as Rfc9421SignRequestOptions, y as HttpMessageSignaturesSpec, z as VerifyPortableObjectProofFailureReason } from "../key-DbLNT-vA.js";
+import { a as VerifySignatureOptions, c as detachSignature, d as verifyJsonLd, f as verifySignature, g as getKeyOwner, h as doesActorOwnKey, i as VerifyJsonLdOptions, l as hasSignatureLike, m as GetKeyOwnerOptions, o as attachSignature, p as DoesActorOwnKeyOptions, r as SignJsonLdOptions, s as createSignature, t as CreateSignatureOptions, u as signJsonLd } from "../ld-Inagww4R.js";
+import { i as verifyPortableObject, n as VerifyPortableObjectOptions, r as VerifyPortableObjectResult, t as VerifyPortableObjectFailureReason } from "../mod-B4kBw1-8.js";
 export { AcceptSignatureMember, AcceptSignatureParameters, CreateProofOptions, CreateSignatureOptions, DoesActorOwnKeyOptions, FetchKeyDetailedResult, FetchKeyErrorResult, FetchKeyOptions, FetchKeyResult, FulfillAcceptSignatureResult, GetKeyOwnerOptions, HttpMessageSignaturesSpec, HttpMessageSignaturesSpecDeterminer, KeyCache, Rfc9421SignRequestOptions, SignJsonLdOptions, SignObjectOptions, SignRequestOptions, VerifyJsonLdOptions, VerifyObjectOptions, VerifyPortableObjectFailureReason, VerifyPortableObjectOptions, VerifyPortableObjectProofFailureReason, VerifyPortableObjectProofOptions, VerifyPortableObjectProofResult, VerifyPortableObjectResult, VerifyProofOptions, VerifyRequestDetailedResult, VerifyRequestFailureReason, VerifyRequestOptions, VerifySignatureOptions, attachSignature, createProof, createSignature, detachSignature, doesActorOwnKey, exportJwk, fetchKey, fetchKeyDetailed, formatAcceptSignature, fulfillAcceptSignature, generateCryptoKeyPair, getKeyOwner, hasProofLike, hasSignatureLike, importJwk, parseAcceptSignature, signJsonLd, signObject, signRequest, validateAcceptSignature, verifyJsonLd, verifyObject, verifyPortableObject, verifyPortableObjectProof, verifyProof, verifyRequest, verifyRequestDetailed, verifySignature };