@fedify/fedify 0.8.0-dev.152 → 0.8.0-dev.154

package/esm/deps/jsr.io/@std/semver/{0.220.1/test_range.js → 0.224.0/_test_comparator_set.js}

@@ -1,10 +1,11 @@
-import { compare } from "./compare.js";
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
 function testComparator(version, comparator) {
     if (isWildcardComparator(comparator)) {
         return true;
     }
-    const cmp = compare(version, comparator.semver ?? comparator);
+    const cmp = compare(version, comparator);
     switch (comparator.operator) {
         case "=":
         case undefined: {
@@ -27,7 +28,7 @@ function testComparator(version, comparator) {
         }
     }
 }
-function testComparatorSet(version, set) {
+export function testComparatorSet(version, set) {
     for (const comparator of set) {
         if (!testComparator(version, comparator)) {
             return false;
@@ -43,11 +44,8 @@ function testComparatorSet(version, set) {
             if (isWildcardComparator(comparator)) {
                 continue;
             }
-            const { prerelease } = comparator.semver ?? comparator;
+            const { major, minor, patch, prerelease } = comparator;
             if (prerelease && prerelease.length > 0) {
-                const major = comparator.semver?.major ?? comparator.major;
-                const minor = comparator.semver?.minor ?? comparator.minor;
-                const patch = comparator.semver?.patch ?? comparator.patch;
                 if (version.major === major && version.minor === minor &&
                     version.patch === patch) {
                     return true;
@@ -58,12 +56,3 @@ function testComparatorSet(version, set) {
     }
     return true;
 }
-/**
- * Test to see if the version satisfies the range.
- * @param version The version to test
- * @param range The range to check
- * @returns true if the version is in the range
- */
-export function testRange(version, range) {
-    return range.some((set) => testComparatorSet(version, set));
-}

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/can_parse.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { parse } from "./parse.js";
 export function canParse(version) {
     try {

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/constants.js

@@ -61,7 +61,6 @@ export const ANY = {
 export const ALL = {
     operator: undefined,
     ...ANY,
-    semver: ANY,
 };
 /**
  * A comparator which will not span any semantic versions
@@ -69,5 +68,4 @@ export const ALL = {
 export const NONE = {
     operator: "<",
     ...MIN,
-    semver: MIN,
 };

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/equals.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { compare } from "./compare.js";
 /**
  * Returns `true` if both semantic versions are logically equivalent, even if they're not the exact same version object.

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/format.js

@@ -1,5 +1,4 @@
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { ANY } from "./constants.js";
+import { isWildcardComparator } from "./_shared.js";
 function formatNumber(value) {
     if (value === Number.POSITIVE_INFINITY) {
         return "∞";
@@ -22,7 +21,7 @@ function formatNumber(value) {
  * @returns The string representation of a semantic version.
  */
 export function format(semver) {
-    if (semver === ANY) {
+    if (isWildcardComparator(semver)) {
         return "*";
     }
     const major = formatNumber(semver.major);

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/format_range.js

@@ -1,8 +1,9 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { format } from "./format.js";
 function formatComparator(comparator) {
-    const { semver, operator } = comparator;
-    return `${operator === undefined ? "" : operator}${format(semver ?? comparator)}`;
+    const { operator } = comparator;
+    return `${operator === undefined ? "" : operator}${format(comparator)}`;
 }
 /**
  * Formats the range into a string

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/greater_than.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { compare } from "./compare.js";
 /**
  * Greater than comparison

package/esm/deps/jsr.io/@std/semver/0.224.0/greater_than_range.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { testComparatorSet } from "./_test_comparator_set.js";
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+/** Check if the semver is greater than the range. */
+export function greaterThanRange(semver, range) {
+    return range.every((comparatorSet) => greaterThanComparatorSet(semver, comparatorSet));
+}
+function greaterThanComparatorSet(semver, comparatorSet) {
+    // If the comparator set contains wildcard, then the semver is not greater than the range.
+    if (comparatorSet.some(isWildcardComparator))
+        return false;
+    // If the semver satisfies the comparator set, then it's not greater than the range.
+    if (testComparatorSet(semver, comparatorSet))
+        return false;
+    // If the semver is less than any of the comparator set, then it's not greater than the range.
+    if (comparatorSet.some((comparator) => lessThanComparator(semver, comparator)))
+        return false;
+    return true;
+}
+function lessThanComparator(semver, comparator) {
+    const cmp = compare(semver, comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined:
+            return cmp < 0;
+        case "!=":
+            return false;
+        case ">":
+            return cmp <= 0;
+        case "<":
+            return false;
+        case ">=":
+            return cmp < 0;
+        case "<=":
+            return false;
+    }
+}

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/increment.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { parseBuild } from "./_shared.js";
 function bumpPrereleaseNumber(prerelease = []) {
     const values = [...prerelease];

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/is_range.js

@@ -7,10 +7,10 @@ function isComparator(value) {
         return false;
     if (value === NONE || value === ALL)
         return true;
-    const { operator, semver } = value;
+    const { operator } = value;
     return ((operator === undefined ||
         OPERATORS.includes(operator)) &&
-        isSemVer(semver));
+        isSemVer(value));
 }
 /**
  * Does a deep check on the object to determine if its a valid range.

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/is_semver.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { ANY, INVALID } from "./constants.js";
 import { isValidNumber, isValidString } from "./_shared.js";
 /**

package/esm/deps/jsr.io/@std/semver/0.224.0/less_than_range.js

@@ -0,0 +1,39 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+import { testComparatorSet } from "./_test_comparator_set.js";
+import { isWildcardComparator } from "./_shared.js";
+import { compare } from "./compare.js";
+/** Check if the semver is less than the range. */
+export function lessThanRange(semver, range) {
+    return range.every((comparatorSet) => lessThanComparatorSet(semver, comparatorSet));
+}
+function lessThanComparatorSet(semver, comparatorSet) {
+    // If the comparator set contains wildcard, then the semver is not greater than the range.
+    if (comparatorSet.some(isWildcardComparator))
+        return false;
+    // If the semver satisfies the comparator set, then it's not less than the range.
+    if (testComparatorSet(semver, comparatorSet))
+        return false;
+    // If the semver is greater than any of the comparator set, then it's not less than the range.
+    if (comparatorSet.some((comparator) => greaterThanComparator(semver, comparator)))
+        return false;
+    return true;
+}
+function greaterThanComparator(semver, comparator) {
+    const cmp = compare(semver, comparator);
+    switch (comparator.operator) {
+        case "=":
+        case undefined:
+            return cmp > 0;
+        case "!=":
+            return false;
+        case ">":
+            return false;
+        case "<":
+            return cmp >= 0;
+        case ">=":
+            return false;
+        case "<=":
+            return cmp > 0;
+    }
+}

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/max_satisfying.js

@@ -1,4 +1,4 @@
-import { testRange } from "./test_range.js";
+import { satisfies } from "./satisfies.js";
 import { greaterThan } from "./greater_than.js";
 /**
  * Returns the highest version in the list that satisfies the range, or `undefined`
@@ -10,7 +10,7 @@ import { greaterThan } from "./greater_than.js";
 export function maxSatisfying(versions, range) {
     let max;
     for (const version of versions) {
-        if (!testRange(version, range))
+        if (!satisfies(version, range))
             continue;
         max = max && greaterThan(max, version) ? max : version;
     }

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/min_satisfying.js

@@ -1,4 +1,4 @@
-import { testRange } from "./test_range.js";
+import { satisfies } from "./satisfies.js";
 import { lessThan } from "./less_than.js";
 /**
  * Returns the lowest version in the list that satisfies the range, or `undefined` if
@@ -10,7 +10,7 @@ import { lessThan } from "./less_than.js";
 export function minSatisfying(versions, range) {
     let min;
     for (const version of versions) {
-        if (!testRange(version, range))
+        if (!satisfies(version, range))
             continue;
         min = min && lessThan(min, version) ? min : version;
     }

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/mod.js

@@ -269,6 +269,7 @@ export * from "./constants.js";
 export * from "./difference.js";
 export * from "./format.js";
 export * from "./test_range.js";
+export * from "./satisfies.js";
 export * from "./increment.js";
 export * from "./is_semver.js";
 export * from "./max_satisfying.js";
@@ -287,7 +288,9 @@ export * from "./format_range.js";
 export * from "./equals.js";
 export * from "./not_equals.js";
 export * from "./greater_than.js";
+export * from "./greater_than_range.js";
 export * from "./greater_or_equal.js";
 export * from "./less_than.js";
+export * from "./less_than_range.js";
 export * from "./less_or_equal.js";
 export const SEMVER_SPEC_VERSION = "2.0.0";

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/parse_range.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { COMPARATOR_REGEXP, OPERATOR_XRANGE_REGEXP, parseBuild, parseNumber, parsePrerelease, XRANGE, } from "./_shared.js";
 import { ALL, ANY, NONE } from "./constants.js";
 function parseComparator(comparator) {
@@ -16,7 +17,7 @@ function parseComparator(comparator) {
             build: buildmetadata ? parseBuild(buildmetadata) : [],
         }
         : ANY;
-    return { operator: operator || undefined, ...semver, semver };
+    return { operator: operator || undefined, ...semver };
 }
 function isWildcard(id) {
     return !id || id.toLowerCase() === "x" || id === "*";

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/range_intersects.js

@@ -1,7 +1,8 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { isWildcardComparator } from "./_shared.js";
 import { compare } from "./compare.js";
-import { testRange } from "./test_range.js";
+import { satisfies } from "./satisfies.js";
 function comparatorIntersects(c0, c1) {
     const op0 = c0.operator;
     const op1 = c1.operator;
@@ -9,12 +10,12 @@ function comparatorIntersects(c0, c1) {
         // if c0 is empty comparator, then returns true
         if (isWildcardComparator(c0))
             return true;
-        return testRange(c0, [[c1]]);
+        return satisfies(c0, [[c1]]);
     }
     if (op1 === undefined) {
         if (isWildcardComparator(c1))
             return true;
-        return testRange(c1, [[c0]]);
+        return satisfies(c1, [[c0]]);
     }
     const cmp = compare(c0, c1);
     const sameDirectionIncreasing = (op0 === ">=" || op0 === ">") &&

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/range_max.js

@@ -1,10 +1,12 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { ANY, INVALID, MAX } from "./constants.js";
-import { testRange } from "./test_range.js";
+// This module is browser compatible.
+import { INVALID, MAX } from "./constants.js";
+import { satisfies } from "./satisfies.js";
 import { greaterThan } from "./greater_than.js";
+import { isWildcardComparator } from "./_shared.js";
 function comparatorMax(comparator) {
-    const semver = comparator.semver ?? comparator;
-    if (semver === ANY)
+    const semver = comparator;
+    if (isWildcardComparator(comparator))
         return MAX;
     switch (comparator.operator) {
         case "!=":
@@ -40,6 +42,12 @@ function comparatorMax(comparator) {
     }
 }
 /**
+ * @deprecated This will be removed in 1.0.0. Use {@linkcode greaterThanRange} or
+ * {@linkcode lessThanRange} for comparing ranges and semvers. The maximum
+ * version of a range is often not well defined, and therefore this API
+ * shouldn't be used. See
+ * {@link https://github.com/denoland/deno_std/issues/4365} for details.
+ *
  * The maximum valid SemVer for a given range or INVALID
  * @param range The range to calculate the max for
  * @returns A valid SemVer or INVALID
@@ -49,7 +57,7 @@ export function rangeMax(range) {
     for (const comparators of range) {
         for (const comparator of comparators) {
             const candidate = comparatorMax(comparator);
-            if (!testRange(candidate, range))
+            if (!satisfies(candidate, range))
                 continue;
             max = (max && greaterThan(max, candidate)) ? max : candidate;
         }

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/range_min.js

@@ -1,12 +1,14 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { ANY, INVALID, MAX, MIN } from "./constants.js";
-import { testRange } from "./test_range.js";
+// This module is browser compatible.
+import { INVALID, MAX, MIN } from "./constants.js";
+import { satisfies } from "./satisfies.js";
 import { lessThan } from "./less_than.js";
 import { greaterThan } from "./greater_than.js";
 import { increment } from "./increment.js";
+import { isWildcardComparator } from "./_shared.js";
 function comparatorMin(comparator) {
-    const semver = comparator.semver ?? comparator;
-    if (semver === ANY)
+    const semver = comparator;
+    if (isWildcardComparator(semver))
         return MIN;
     switch (comparator.operator) {
         case ">":
@@ -31,6 +33,12 @@ function comparatorMin(comparator) {
     }
 }
 /**
+ * @deprecated This will be removed in 1.0.0. Use {@linkcode greaterThanRange} or
+ * {@linkcode lessThanRange} for comparing ranges and semvers. The minimum
+ * version of a range is often not well defined, and therefore this API
+ * shouldn't be used. See
+ * {@link https://github.com/denoland/deno_std/issues/4365} for details.
+ *
  * The minimum valid SemVer for a given range or INVALID
  * @param range The range to calculate the min for
  * @returns A valid SemVer or INVALID
@@ -40,7 +48,7 @@ export function rangeMin(range) {
     for (const comparators of range) {
         for (const comparator of comparators) {
             const candidate = comparatorMin(comparator);
-            if (!testRange(candidate, range))
+            if (!satisfies(candidate, range))
                 continue;
             min = (min && lessThan(min, candidate)) ? min : candidate;
         }

package/esm/deps/jsr.io/@std/semver/0.224.0/satisfies.js

@@ -0,0 +1,11 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+import { testComparatorSet } from "./_test_comparator_set.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ */
+export function satisfies(version, range) {
+    return range.some((set) => testComparatorSet(version, set));
+}

package/esm/deps/jsr.io/@std/semver/0.224.0/test_range.js

@@ -0,0 +1,13 @@
+import { satisfies } from "./satisfies.js";
+/**
+ * Test to see if the version satisfies the range.
+ * @param version The version to test
+ * @param range The range to check
+ * @returns true if the version is in the range
+ *
+ * @deprecated This will be removed in 1.0.0. Use {@linkcode satisfies}
+ * instead. See https://github.com/denoland/deno_std/pull/4364.
+ */
+export function testRange(version, range) {
+    return satisfies(version, range);
+}

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/try_parse_range.js

@@ -1,4 +1,5 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 import { parseRange } from "./parse_range.js";
 /**
  * A tries to parse a valid Range string or returns undefined

package/esm/deps/jsr.io/@std/semver/{0.220.1 → 0.224.0}/types.js

@@ -1,2 +1,3 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
 export {};

package/esm/federation/collection.js

@@ -1,5 +1,5 @@
 import * as dntShim from "../_dnt.shims.js";
-import { encodeHex } from "../deps/jsr.io/@std/encoding/0.220.1/hex.js";
+import { encodeHex } from "../deps/jsr.io/@std/encoding/0.224.0/hex.js";
 /**
  * Calculates the [partial follower collection digest][1].
  *

package/esm/federation/handler.js

@@ -1,6 +1,6 @@
 import * as dntShim from "../_dnt.shims.js";
 import { getLogger } from "@logtape/logtape";
-import { accepts } from "../deps/jsr.io/@std/http/0.220.1/negotiation.js";
+import { accepts } from "../deps/jsr.io/@std/http/0.224.0/negotiation.js";
 import { doesActorOwnKey, verify } from "../httpsig/mod.js";
 import { Activity, Link, Object, OrderedCollection, OrderedCollectionPage, } from "../vocab/vocab.js";
 export function acceptsJsonLd(request) {

package/esm/federation/send.js

@@ -42,7 +42,13 @@ export async function sendActivity({ activity, privateKey, keyId, inbox, documen
     request = await sign(request, privateKey, keyId);
     const response = await fetch(request);
     if (!response.ok) {
-        const error = await response.text();
+        let error;
+        try {
+            error = await response.text();
+        }
+        catch (_) {
+            error = "";
+        }
         logger.error("Failed to send activity {activityId} to {inbox} ({status} " +
             "{statusText}):\n{error}", {
             activityId: activity.id?.href,

package/esm/httpsig/mod.js

@@ -5,8 +5,9 @@
  * @module
  */
 import * as dntShim from "../_dnt.shims.js";
-import { equals } from "../deps/jsr.io/@std/bytes/0.220.1/mod.js";
-import { decodeBase64, encodeBase64 } from "../deps/jsr.io/@std/encoding/0.220.1/base64.js";
+import { getLogger } from "@logtape/logtape";
+import { equals } from "../deps/jsr.io/@std/bytes/0.224.0/mod.js";
+import { decodeBase64, encodeBase64 } from "../deps/jsr.io/@std/encoding/0.224.0/base64.js";
 import { isActor } from "../vocab/actor.js";
 import { CryptographicKey, Object as ASObject, } from "../vocab/vocab.js";
 import { validateCryptoKey } from "./key.js";
@@ -73,16 +74,22 @@ const supportedHashAlgorithms = {
  *          could not be verified.
  */
 export async function verify(request, documentLoader, currentTime) {
+    const logger = getLogger(["fedify", "httpsig", "verify"]);
     request = request.clone();
     const dateHeader = request.headers.get("Date");
-    if (dateHeader == null)
+    if (dateHeader == null) {
+        logger.debug("Failed to verify; no Date header found.", { headers: Object.fromEntries(request.headers.entries()) });
         return null;
+    }
     const sigHeader = request.headers.get("Signature");
-    if (sigHeader == null)
+    if (sigHeader == null) {
+        logger.debug("Failed to verify; no Signature header found.", { headers: Object.fromEntries(request.headers.entries()) });
         return null;
+    }
     const digestHeader = request.headers.get("Digest");
     if (request.method !== "GET" && request.method !== "HEAD" &&
         digestHeader == null) {
+        logger.debug("Failed to verify; no Digest header found.", { headers: Object.fromEntries(request.headers.entries()) });
         return null;
     }
     let body = null;
@@ -96,30 +103,60 @@ export async function verify(request, documentLoader, currentTime) {
                 continue;
             const digest = decodeBase64(digestBase64);
             const expectedDigest = await dntShim.crypto.subtle.digest(supportedHashAlgorithms[algo], body);
-            if (!equals(digest, new Uint8Array(expectedDigest)))
+            if (!equals(digest, new Uint8Array(expectedDigest))) {
+                logger.debug("Failed to verify; digest mismatch ({algorithm}): " +
+                    "{digest} != {expectedDigest}.", {
+                    algorithm: algo,
+                    digest: digestBase64,
+                    expectedDigest: encodeBase64(expectedDigest),
+                });
                 return null;
+            }
             matched = true;
         }
-        if (!matched)
+        if (!matched) {
+            logger.debug("Failed to verify; no supported digest algorithm found.  " +
+                "Supported: {supportedAlgorithms}; found: {algorithms}.", {
+                supportedAlgorithms: Object.keys(supportedHashAlgorithms),
+                algorithms: digests.map(([algo]) => algo),
+            });
             return null;
+        }
     }
     const date = dntShim.Temporal.Instant.from(new Date(dateHeader).toISOString());
     const now = currentTime ?? dntShim.Temporal.Now.instant();
     if (dntShim.Temporal.Instant.compare(date, now.add({ seconds: 30 })) > 0) {
-        // Too far in the future
+        logger.debug("Failed to verify; Date is too far in the future.", { date: date.toString(), now: now.toString() });
         return null;
     }
     else if (dntShim.Temporal.Instant.compare(date, now.subtract({ seconds: 30 })) < 0) {
-        // Too far in the past
+        logger.debug("Failed to verify; Date is too far in the past.", { date: date.toString(), now: now.toString() });
         return null;
     }
     const sigValues = Object.fromEntries(sigHeader.split(",").map((pair) => pair.match(/^\s*([A-Za-z]+)="([^"]*)"\s*$/)).filter((m) => m != null).map((m) => m.slice(1, 3)));
-    if (!("keyId" in sigValues && "headers" in sigValues &&
-        "signature" in sigValues)) {
+    if (!("keyId" in sigValues)) {
+        logger.debug("Failed to verify; no keyId field found in the Signature header.", { signature: sigHeader });
+        return null;
+    }
+    else if (!("headers" in sigValues)) {
+        logger.debug("Failed to verify; no headers field found in the Signature header.", { signature: sigHeader });
+        return null;
+    }
+    else if (!("signature" in sigValues)) {
+        logger.debug("Failed to verify; no signature field found in the Signature header.", { signature: sigHeader });
         return null;
     }
     const { keyId, headers, signature } = sigValues;
-    const { document } = await documentLoader(keyId);
+    logger.debug("Fetching key {keyId} to verify signature...", { keyId });
+    let document;
+    try {
+        const remoteDocument = await documentLoader(keyId);
+        document = remoteDocument.document;
+    }
+    catch (_) {
+        logger.debug("Failed to fetch key {keyId}.", { keyId });
+        return null;
+    }
     let object;
     try {
         object = await ASObject.fromJsonLd(document, { documentLoader });
@@ -131,8 +168,10 @@ export async function verify(request, documentLoader, currentTime) {
             object = await CryptographicKey.fromJsonLd(document, { documentLoader });
         }
         catch (e) {
-            if (e instanceof TypeError)
+            if (e instanceof TypeError) {
+                logger.debug("Failed to verify; key {keyId} returned an invalid object.", { keyId });
                 return null;
+            }
             throw e;
         }
     }
@@ -146,19 +185,31 @@ export async function verify(request, documentLoader, currentTime) {
                 break;
             }
         }
-        if (key == null)
+        if (key == null) {
+            logger.debug("Failed to verify; object {keyId} returned an {actorType}, " +
+                "but has no key matching {keyId}.", { keyId, actorType: object.constructor.name });
             return null;
+        }
     }
-    else
+    else {
+        logger.debug("Failed to verify; key {keyId} returned an invalid object.", { keyId });
         return null;
-    if (key.publicKey == null)
+    }
+    if (key.publicKey == null) {
+        logger.debug("Failed to verify; key {keyId} has no publicKeyPem field.", { keyId });
         return null;
+    }
     const headerNames = headers.split(/\s+/g);
     if (!headerNames.includes("(request-target)") || !headerNames.includes("date")) {
+        logger.debug("Failed to verify; required headers missing in the Signature header: " +
+            "{headers}.", { headers });
         return null;
     }
-    if (body != null && !headerNames.includes("digest"))
+    if (body != null && !headerNames.includes("digest")) {
+        logger.debug("Failed to verify; required headers missing in the Signature header: " +
+            "{headers}.", { headers });
         return null;
+    }
     const message = headerNames.map((name) => `${name}: ` +
         (name == "(request-target)"
             ? `${request.method.toLowerCase()} ${new URL(request.url).pathname}`
@@ -168,7 +219,13 @@ export async function verify(request, documentLoader, currentTime) {
     const sig = decodeBase64(signature);
     // TODO: support other than RSASSA-PKCS1-v1_5:
     const verified = await dntShim.crypto.subtle.verify("RSASSA-PKCS1-v1_5", key.publicKey, sig, new TextEncoder().encode(message));
-    return verified ? key : null;
+    if (!verified) {
+        logger.debug("Failed to verify; signature {signature} is invalid.  " +
+            "Check if the key is correct or if the signed message is correct.  " +
+            "The message to sign is:\n{message}", { signature, message });
+        return null;
+    }
+    return key;
 }
 /**
  * Checks if the actor of the given activity owns the specified key.

package/esm/nodeinfo/types.js

@@ -1,4 +1,4 @@
-import { format } from "../deps/jsr.io/@std/semver/0.220.1/mod.js";
+import { format } from "../deps/jsr.io/@std/semver/0.224.0/mod.js";
 /**
  * Converts a {@link NodeInfo} object to a JSON value.
  * @param nodeInfo The {@link NodeInfo} object to convert.