@fedify/fedify 2.1.0-dev.543 → 2.1.0-dev.592

package/dist/nodeinfo/handler.test.js

@@ -3,35 +3,36 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { test } from "../dist-B5f6a8Tt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-QzKcOQgP.js";
-import "../deno-9yc0TPBI.js";
-import { createFederation, handleNodeInfo, handleNodeInfoJrd } from "../middleware-FZ0T8vIp.js";
-import "../client-Dg7OfUDA.js";
+import "../deno-OR506Yti.js";
+import { createFederation, handleNodeInfo, handleNodeInfoJrd } from "../middleware-DzICTgdC.js";
+import "../client-CoCIaTNO.js";
 import "../router-D9eI0s4b.js";
 import "../types-CPz01LGH.js";
-import "../key-DFG6tJgw.js";
-import "../http-CpvoK0Y7.js";
-import "../ld-DVnRS9IK.js";
-import "../owner-MCqkZ1KE.js";
-import "../proof-D2B3jvnF.js";
-import "../docloader-6Wrqp6SE.js";
-import "../kv-cache-B__dHl7g.js";
-import "../inbox-DMq3a5bc.js";
-import "../builder-BBucr-Bp.js";
-import "../collection-CcnIw1qY.js";
-import "../keycache-C7k8s1Bk.js";
-import "../negotiation-5NPJL6zp.js";
-import "../retry-D4GJ670a.js";
-import "../send-DtP5YkuY.js";
-import "../std__assert-DWivtrGR.js";
-import "../assert_rejects-Ce45JcFg.js";
-import "../assert_throws-BNXdRGWP.js";
-import "../assert_not_equals-C80BG-_5.js";
-import { createRequestContext } from "../context-CZ5llAss.js";
+import "../accept-D7sAxyNa.js";
+import "../key-Cx3Tx_In.js";
+import "../http-BUCxbGks.js";
+import "../ld-CLMJw_iX.js";
+import "../owner-D5J299vd.js";
+import "../proof-BBLHhWMC.js";
+import "../docloader-BG_pP2fW.js";
+import "../kv-cache-Bw2F2ABq.js";
+import "../inbox-D_LU1opv.js";
+import "../builder-B24i8eYp.js";
+import "../collection-CSzG2j1P.js";
+import "../keycache-CpGWAUbj.js";
+import "../negotiation-BlAuS_nr.js";
+import "../retry-mqLf4b-R.js";
+import "../send-2b0Fn9cn.js";
+import "../std__assert-X-_kMxKM.js";
+import "../assert_rejects-0h7I2Esa.js";
+import "../assert_throws-rjdMBf31.js";
+import "../assert_not_equals-f3m3epl3.js";
+import { createRequestContext } from "../context-Aqenou7c.js";
+import { test } from "@fedify/fixture";
 
 //#region src/nodeinfo/handler.test.ts
 test("handleNodeInfo()", async () => {

package/dist/nodeinfo/types.test.js

@@ -3,15 +3,15 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { test } from "../dist-B5f6a8Tt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
 import { nodeInfoToJson } from "../types-CPz01LGH.js";
-import "../std__assert-DWivtrGR.js";
-import "../assert_rejects-Ce45JcFg.js";
-import { assertThrows } from "../assert_throws-BNXdRGWP.js";
-import "../assert_not_equals-C80BG-_5.js";
+import "../std__assert-X-_kMxKM.js";
+import "../assert_rejects-0h7I2Esa.js";
+import { assertThrows } from "../assert_throws-rjdMBf31.js";
+import "../assert_not_equals-f3m3epl3.js";
+import { test } from "@fedify/fixture";
 
 //#region src/nodeinfo/types.test.ts
 test("nodeInfoToJson()", () => {

package/dist/otel/exporter.test.js

@@ -3,18 +3,18 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { test } from "../dist-B5f6a8Tt.js";
 import { assertEquals } from "../assert_equals-DSbWqCm3.js";
 import "../assert-MZs1qjMx.js";
 import "../assert_instance_of-DHz7EHNU.js";
 import { MemoryKvStore } from "../kv-QzKcOQgP.js";
-import "../std__assert-DWivtrGR.js";
-import "../assert_rejects-Ce45JcFg.js";
-import "../assert_throws-BNXdRGWP.js";
-import "../assert_not_equals-C80BG-_5.js";
+import "../std__assert-X-_kMxKM.js";
+import "../assert_rejects-0h7I2Esa.js";
+import "../assert_throws-rjdMBf31.js";
+import "../assert_not_equals-f3m3epl3.js";
+import { test } from "@fedify/fixture";
 import { getLogger } from "@logtape/logtape";
-import { ExportResultCode } from "@opentelemetry/core";
 import { SpanKind, SpanStatusCode, TraceFlags } from "@opentelemetry/api";
+import { ExportResultCode } from "@opentelemetry/core";
 
 //#region src/otel/exporter.ts
 /**

package/dist/{owner-MCqkZ1KE.js → owner-D5J299vd.js}

@@ -3,7 +3,7 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { deno_default } from "./deno-9yc0TPBI.js";
+import { deno_default } from "./deno-OR506Yti.js";
 import { CryptographicKey, Object as Object$1, isActor } from "@fedify/vocab";
 import { getDocumentLoader } from "@fedify/vocab-runtime";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";

package/dist/{proof-D2B3jvnF.js → proof-BBLHhWMC.js}

@@ -3,10 +3,10 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { deno_default } from "./deno-9yc0TPBI.js";
-import { fetchKey, validateCryptoKey } from "./key-DFG6tJgw.js";
-import { getLogger } from "@logtape/logtape";
+import { deno_default } from "./deno-OR506Yti.js";
+import { fetchKey, validateCryptoKey } from "./key-Cx3Tx_In.js";
 import { Activity, DataIntegrityProof, Multikey, getTypeId } from "@fedify/vocab";
+import { getLogger } from "@logtape/logtape";
 import { SpanStatusCode, trace } from "@opentelemetry/api";
 import { encodeHex } from "byte-encodings/hex";
 import serialize from "json-canon";

package/dist/{proof-BF_LZjDb.cjs → proof-BVl5IgbN.cjs}

@@ -3,14 +3,14 @@
           const { URLPattern } = require("urlpattern-polyfill");
         
 const require_chunk = require('./chunk-CGaQZ11T.cjs');
-const require_http = require('./http-C_9L2wFv.cjs');
+const require_http = require('./http-CaXARmaJ.cjs');
 const __logtape_logtape = require_chunk.__toESM(require("@logtape/logtape"));
 const __fedify_vocab = require_chunk.__toESM(require("@fedify/vocab"));
 const __opentelemetry_api = require_chunk.__toESM(require("@opentelemetry/api"));
 const byte_encodings_hex = require_chunk.__toESM(require("byte-encodings/hex"));
 const byte_encodings_base64 = require_chunk.__toESM(require("byte-encodings/base64"));
 const __fedify_vocab_runtime = require_chunk.__toESM(require("@fedify/vocab-runtime"));
-const jsonld = require_chunk.__toESM(require("jsonld"));
+const __fedify_vocab_runtime_jsonld = require_chunk.__toESM(require("@fedify/vocab-runtime/jsonld"));
 const json_canon = require_chunk.__toESM(require("json-canon"));
 
 //#region src/sig/ld.ts
@@ -257,7 +257,7 @@ async function verifyJsonLd(jsonLd, options = {}) {
 	});
 }
 async function hashJsonLd(jsonLd, contextLoader) {
-	const canon = await jsonld.default.canonize(jsonLd, {
+	const canon = await __fedify_vocab_runtime_jsonld.default.canonize(jsonLd, {
 		format: "application/n-quads",
 		documentLoader: contextLoader ?? (0, __fedify_vocab_runtime.getDocumentLoader)()
 	});

package/dist/{proof-ooYMfVCa.js → proof-CiCp_mCG.js}

@@ -2,14 +2,14 @@
           import { Temporal } from "@js-temporal/polyfill";
           import { URLPattern } from "urlpattern-polyfill";
         
-import { deno_default, fetchKey, validateCryptoKey } from "./http-DxwzIU0F.js";
+import { deno_default, fetchKey, validateCryptoKey } from "./http-DePHjWKP.js";
 import { getLogger } from "@logtape/logtape";
 import { Activity, CryptographicKey, DataIntegrityProof, Multikey, Object as Object$1, getTypeId, isActor } from "@fedify/vocab";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 import { encodeHex } from "byte-encodings/hex";
 import { decodeBase64, encodeBase64 } from "byte-encodings/base64";
 import { getDocumentLoader } from "@fedify/vocab-runtime";
-import jsonld from "jsonld";
+import jsonld from "@fedify/vocab-runtime/jsonld";
 import serialize from "json-canon";
 
 //#region src/sig/ld.ts

package/dist/{send-DtP5YkuY.js → send-2b0Fn9cn.js}

@@ -3,8 +3,8 @@
       import { URLPattern } from "urlpattern-polyfill";
       globalThis.addEventListener = () => {};
     
-import { deno_default } from "./deno-9yc0TPBI.js";
-import { doubleKnock } from "./http-CpvoK0Y7.js";
+import { deno_default } from "./deno-OR506Yti.js";
+import { doubleKnock } from "./http-BUCxbGks.js";
 import { getLogger } from "@logtape/logtape";
 import { SpanKind, SpanStatusCode, trace } from "@opentelemetry/api";
 

package/dist/sig/accept.test.d.ts

@@ -0,0 +1,3 @@
+import { Temporal } from "@js-temporal/polyfill";
+import { URLPattern } from "urlpattern-polyfill";
+globalThis.addEventListener = () => {};

package/dist/sig/accept.test.js

@@ -0,0 +1,451 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+      globalThis.addEventListener = () => {};
+    
+import { formatAcceptSignature, fulfillAcceptSignature, parseAcceptSignature, validateAcceptSignature } from "../accept-D7sAxyNa.js";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, strictEqual } from "node:assert/strict";
+
+//#region src/sig/accept.test.ts
+test("parseAcceptSignature(): single entry", () => {
+	const result = parseAcceptSignature("sig1=(\"@method\" \"@target-uri\")");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}, {
+			value: "@target-uri",
+			params: {}
+		}],
+		parameters: {}
+	}]);
+});
+test("parseAcceptSignature(): multiple entries", () => {
+	const result = parseAcceptSignature("sig1=(\"@method\"), sig2=(\"@authority\")");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: {}
+	}, {
+		label: "sig2",
+		components: [{
+			value: "@authority",
+			params: {}
+		}],
+		parameters: {}
+	}]);
+});
+test("parseAcceptSignature(): all six parameters", () => {
+	const result = parseAcceptSignature("sig1=(\"@method\");keyid=\"k1\";alg=\"rsa-v1_5-sha256\";created;expires;nonce=\"abc\";tag=\"t1\"");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: {
+			keyid: "k1",
+			alg: "rsa-v1_5-sha256",
+			created: true,
+			expires: true,
+			nonce: "abc",
+			tag: "t1"
+		}
+	}]);
+});
+test("parseAcceptSignature(): preserves string component parameters", () => {
+	const result = parseAcceptSignature("sig1=(\"@query-param\";name=\"foo\" \"@method\")");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "@query-param",
+			params: { name: "foo" }
+		}, {
+			value: "@method",
+			params: {}
+		}],
+		parameters: {}
+	}]);
+});
+test("parseAcceptSignature(): preserves boolean component parameters", () => {
+	const result = parseAcceptSignature("sig1=(\"content-type\";sf \"content-digest\";bs)");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "content-type",
+			params: { sf: true }
+		}, {
+			value: "content-digest",
+			params: { bs: true }
+		}],
+		parameters: {}
+	}]);
+});
+test("parseAcceptSignature(): preserves multiple parameters on one component", () => {
+	const result = parseAcceptSignature("sig1=(\"@request-response\";key=\"sig1\";req)");
+	deepStrictEqual(result, [{
+		label: "sig1",
+		components: [{
+			value: "@request-response",
+			params: {
+				key: "sig1",
+				req: true
+			}
+		}],
+		parameters: {}
+	}]);
+});
+test("parseAcceptSignature(): malformed header", () => {
+	deepStrictEqual(parseAcceptSignature("not a valid structured field"), []);
+	deepStrictEqual(parseAcceptSignature(""), []);
+});
+test("formatAcceptSignature(): single entry with created", () => {
+	const members = [{
+		label: "sig1",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			}
+		],
+		parameters: { created: true }
+	}];
+	const header = formatAcceptSignature(members);
+	const parsed = parseAcceptSignature(header);
+	deepStrictEqual(parsed, members);
+});
+test("formatAcceptSignature(): created + nonce", () => {
+	const members = [{
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: {
+			created: true,
+			nonce: "dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"
+		}
+	}];
+	const header = formatAcceptSignature(members);
+	const parsed = parseAcceptSignature(header);
+	deepStrictEqual(parsed, members);
+});
+test("formatAcceptSignature(): multiple entries", () => {
+	const members = [{
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: {}
+	}, {
+		label: "sig2",
+		components: [{
+			value: "@authority",
+			params: {}
+		}, {
+			value: "content-digest",
+			params: {}
+		}],
+		parameters: { tag: "app-123" }
+	}];
+	const header = formatAcceptSignature(members);
+	const parsed = parseAcceptSignature(header);
+	deepStrictEqual(parsed, members);
+});
+test("formatAcceptSignature(): round-trip with all parameters", () => {
+	const input = [{
+		label: "sig1",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			},
+			{
+				value: "content-digest",
+				params: {}
+			}
+		],
+		parameters: {
+			keyid: "test-key-rsa-pss",
+			alg: "rsa-pss-sha512",
+			created: true,
+			expires: true,
+			nonce: "abc123",
+			tag: "app-123"
+		}
+	}];
+	const header = formatAcceptSignature(input);
+	const members = parseAcceptSignature(header);
+	deepStrictEqual(members, input);
+});
+test("formatAcceptSignature(): round-trip with parameterized components", () => {
+	const input = [{
+		label: "sig1",
+		components: [
+			{
+				value: "@query-param",
+				params: { name: "foo" }
+			},
+			{
+				value: "content-type",
+				params: { sf: true }
+			},
+			{
+				value: "@method",
+				params: {}
+			}
+		],
+		parameters: { created: true }
+	}];
+	const header = formatAcceptSignature(input);
+	const members = parseAcceptSignature(header);
+	deepStrictEqual(members, input);
+});
+test("validateAcceptSignature(): filters out @status", () => {
+	const valid = {
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}, {
+			value: "@target-uri",
+			params: {}
+		}],
+		parameters: {}
+	};
+	const invalid = {
+		label: "sig2",
+		components: [{
+			value: "@method",
+			params: {}
+		}, {
+			value: "@status",
+			params: {}
+		}],
+		parameters: {}
+	};
+	const validOnly = [valid];
+	deepStrictEqual(validateAcceptSignature(validOnly), [valid]);
+	const invalidOnly = [invalid];
+	deepStrictEqual(validateAcceptSignature(invalidOnly), []);
+	const mixed = [valid, invalid];
+	deepStrictEqual(validateAcceptSignature(mixed), [valid]);
+});
+test("validateAcceptSignature(): passes entries with parameterized components", () => {
+	const members = [{
+		label: "sig1",
+		components: [{
+			value: "@query-param",
+			params: { name: "foo" }
+		}, {
+			value: "@method",
+			params: {}
+		}],
+		parameters: {}
+	}];
+	deepStrictEqual(validateAcceptSignature(members), members);
+});
+test("fulfillAcceptSignature(): compatible alg and keyid", () => {
+	const entry = {
+		label: "sig1",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "content-digest",
+				params: {}
+			}
+		],
+		parameters: {
+			alg: "rsa-v1_5-sha256",
+			keyid: "https://example.com/key",
+			nonce: "abc",
+			tag: "t1"
+		}
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	deepStrictEqual(result, {
+		label: "sig1",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "content-digest",
+				params: {}
+			}
+		],
+		nonce: "abc",
+		tag: "t1",
+		expires: void 0
+	});
+});
+test("fulfillAcceptSignature(): incompatible alg", () => {
+	const entry = {
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: { alg: "ecdsa-p256-sha256" }
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	strictEqual(result, null);
+});
+test("fulfillAcceptSignature(): incompatible keyid", () => {
+	const entry = {
+		label: "sig1",
+		components: [{
+			value: "@method",
+			params: {}
+		}],
+		parameters: { keyid: "https://other.example/key" }
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	strictEqual(result, null);
+});
+test("fulfillAcceptSignature(): components returned exactly as requested", () => {
+	const entry = {
+		label: "sig1",
+		components: [{
+			value: "content-digest",
+			params: {}
+		}],
+		parameters: {}
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	deepStrictEqual(result.components, [{
+		value: "content-digest",
+		params: {}
+	}]);
+});
+test("fulfillAcceptSignature(): no alg/keyid constraints", () => {
+	const entry = {
+		label: "custom",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			}
+		],
+		parameters: {}
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	deepStrictEqual(result, {
+		label: "custom",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			}
+		],
+		nonce: void 0,
+		tag: void 0,
+		expires: void 0
+	});
+});
+test("fulfillAcceptSignature(): passes through expires when requested", () => {
+	const entry = {
+		label: "sig1",
+		components: [
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			}
+		],
+		parameters: { expires: true }
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	strictEqual(result != null, true);
+	strictEqual(result.expires, true);
+});
+test("fulfillAcceptSignature(): preserves component parameters in result", () => {
+	const entry = {
+		label: "sig1",
+		components: [
+			{
+				value: "@query-param",
+				params: { name: "foo" }
+			},
+			{
+				value: "@method",
+				params: {}
+			},
+			{
+				value: "@target-uri",
+				params: {}
+			},
+			{
+				value: "@authority",
+				params: {}
+			}
+		],
+		parameters: {}
+	};
+	const result = fulfillAcceptSignature(entry, "https://example.com/key", "rsa-v1_5-sha256");
+	strictEqual(result != null, true);
+	const qp = result.components.find((c) => c.value === "@query-param");
+	deepStrictEqual(qp, {
+		value: "@query-param",
+		params: { name: "foo" }
+	});
+});
+
+//#endregion