@upstash/qstash 0.3.0 → 0.3.2

package/README.md

@@ -95,6 +95,10 @@ const r = new Receiver({
 const isValid = await r.verify({
   /**
    * The signature from the `Upstash-Signature` header.
+   *
+   * Please note that on some platforms (e.g. Vercel or Netlify) you might
+   * receive the header in lower case: `upstash-signature` 
+   *
    */
   signature: "string";
 

package/esm/deps/deno.land/{std@0.164.0 → std@0.167.0}/crypto/keystack.js

@@ -68,8 +68,7 @@ async function compare(a, b) {
  *
  * This was inspired by [keygrip](https://github.com/crypto-utils/keygrip/).
  *
- * ### Example
- *
+ * @example
  * ```ts
  * import { KeyStack } from "https://deno.land/std@$STD_VERSION/crypto/keystack.ts";
  *

package/esm/deps/deno.land/{std@0.164.0 → std@0.167.0}/crypto/mod.js

@@ -2,11 +2,12 @@
 /**
  * Extensions to the
  * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
- * supporting additional encryption APIs.
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
  *
  * Provides additional digest algorithms that are not part of the WebCrypto
  * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
- * also provide a `subtle.timingSafeEqual()` method to compare array buffers
+ * also provides a `subtle.timingSafeEqual()` method to compare array buffers
  * or data views in a way that isn't prone to timing based attacks.
  *
  * The "polyfill" delegates to `WebCrypto` where possible.
@@ -15,6 +16,155 @@
  * for managing rotatable keys for signing data to prevent tampering, like with
  * HTTP cookies.
  *
+ * ## Supported algorithms
+ *
+ * Here is a list of supported algorithms. If the algorithm name in WebCrypto
+ * and Wasm/Rust is the same, this library prefers to use algorithms that are
+ * supported by WebCrypto.
+ *
+ * WebCrypto
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/mod.ts
+ * const webCryptoDigestAlgorithms = [
+ *   "SHA-384",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (length-extendable and collidable):
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * Wasm/Rust
+ *
+ * ```ts
+ * // https://deno.land/std/_wasm_crypto/mod.ts
+ * export const digestAlgorithms = [
+ *   "BLAKE2B-256",
+ *   "BLAKE2B-384",
+ *   "BLAKE2B",
+ *   "BLAKE2S",
+ *   "BLAKE3",
+ *   "KECCAK-224",
+ *   "KECCAK-256",
+ *   "KECCAK-384",
+ *   "KECCAK-512",
+ *   "SHA-384",
+ *   "SHA3-224",
+ *   "SHA3-256",
+ *   "SHA3-384",
+ *   "SHA3-512",
+ *   "SHAKE128",
+ *   "SHAKE256",
+ *   "TIGER",
+ *   // insecure (length-extendable):
+ *   "RIPEMD-160",
+ *   "SHA-224",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (collidable and length-extendable):
+ *   "MD5",
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * ## Timing safe comparison
+ *
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * [w3c/webcrypto#270](https://github.com/w3c/webcrypto/issues/270)), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const c = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello deno"),
+ * );
+ *
+ * assert(crypto.subtle.timingSafeEqual(a, b));
+ * assert(!crypto.subtle.timingSafeEqual(a, c));
+ * ```
+ *
+ * In addition to the method being part of the `crypto.subtle` interface, it is
+ * also loadable directly:
+ *
+ * ```ts
+ * import { timingSafeEqual } from "https://deno.land/std@$STD_VERSION/crypto/timing_safe_equal.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * // This will delegate to the runtime's WebCrypto implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "SHA-384",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ *
+ * // This will use a bundled Wasm/Rust implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "BLAKE3",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * @example Convert hash to a string
+ *
+ * ```ts
+ * import {
+ *   crypto,
+ *   toHashString,
+ * } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * const hash = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("You hear that Mr. Anderson?"),
+ * );
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ *
  * @module
  */
 import * as dntShim from "../../../../_dnt.shims.js";

package/esm/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/base64.js

@@ -5,6 +5,23 @@
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * const b64Repr = "Zm9vYg==";
+ *
+ * const binaryData = decode(b64Repr);
+ * console.log(binaryData);
+ * // => Uint8Array [ 102, 111, 111, 98 ]
+ *
+ * console.log(encode(binaryData));
+ * // => Zm9vYg==
+ * ```
+ *
  * @module
  */
 const base64abc = [

package/esm/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/base64url.js

@@ -5,6 +5,22 @@
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64url.ts";
+ *
+ * const binary = new TextEncoder().encode("foobar");
+ * const encoded = encode(binary);
+ * console.log(encoded);
+ * // => "Zm9vYmFy"
+ *
+ * console.log(decode(encoded));
+ * // => Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * ```
+ *
  * @module
  */
 import * as base64 from "./base64.js";

package/esm/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/hex.js

@@ -7,6 +7,22 @@
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/hex.ts";
+ *
+ * const binary = new TextEncoder().encode("abc");
+ * const encoded = encode(binary);
+ * console.log(encoded);
+ * // => Uint8Array(6) [ 54, 49, 54, 50, 54, 51 ]
+ *
+ * console.log(decode(encoded));
+ * // => Uint8Array(3) [ 97, 98, 99 ]
+ * ```
+ *
  * @module
  */
 const hexTable = new TextEncoder().encode("0123456789abcdef");

package/esm/pkg/receiver.js

@@ -74,7 +74,7 @@ export class Receiver {
             console.log({ now, exp: p.exp });
             throw new SignatureError("token has expired");
         }
-        if (now - (req.clockTolerance ?? 0) < p.nbf) {
+        if (now + (req.clockTolerance ?? 0) < p.nbf) {
             throw new SignatureError("token is not yet valid");
         }
         const bodyHash = await this.subtleCrypto.digest("SHA-256", typeof req.body === "string"

package/package.json

@@ -3,7 +3,7 @@
   "main": "./script/entrypoints/nodejs.js",
   "types": "./types/entrypoints/nodejs.d.ts",
   "name": "@upstash/qstash",
-  "version": "v0.3.0",
+  "version": "v0.3.2",
   "description": "Official Deno/Typescript client for QStash",
   "repository": {
     "type": "git",

package/script/deps/deno.land/{std@0.164.0 → std@0.167.0}/crypto/keystack.js

@@ -94,8 +94,7 @@ async function compare(a, b) {
  *
  * This was inspired by [keygrip](https://github.com/crypto-utils/keygrip/).
  *
- * ### Example
- *
+ * @example
  * ```ts
  * import { KeyStack } from "https://deno.land/std@$STD_VERSION/crypto/keystack.ts";
  *

package/script/deps/deno.land/{std@0.164.0 → std@0.167.0}/crypto/mod.js

@@ -28,11 +28,12 @@ exports.crypto = exports.toHashString = exports.KeyStack = void 0;
 /**
  * Extensions to the
  * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
- * supporting additional encryption APIs.
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
  *
  * Provides additional digest algorithms that are not part of the WebCrypto
  * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
- * also provide a `subtle.timingSafeEqual()` method to compare array buffers
+ * also provides a `subtle.timingSafeEqual()` method to compare array buffers
  * or data views in a way that isn't prone to timing based attacks.
  *
  * The "polyfill" delegates to `WebCrypto` where possible.
@@ -41,6 +42,155 @@ exports.crypto = exports.toHashString = exports.KeyStack = void 0;
  * for managing rotatable keys for signing data to prevent tampering, like with
  * HTTP cookies.
  *
+ * ## Supported algorithms
+ *
+ * Here is a list of supported algorithms. If the algorithm name in WebCrypto
+ * and Wasm/Rust is the same, this library prefers to use algorithms that are
+ * supported by WebCrypto.
+ *
+ * WebCrypto
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/mod.ts
+ * const webCryptoDigestAlgorithms = [
+ *   "SHA-384",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (length-extendable and collidable):
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * Wasm/Rust
+ *
+ * ```ts
+ * // https://deno.land/std/_wasm_crypto/mod.ts
+ * export const digestAlgorithms = [
+ *   "BLAKE2B-256",
+ *   "BLAKE2B-384",
+ *   "BLAKE2B",
+ *   "BLAKE2S",
+ *   "BLAKE3",
+ *   "KECCAK-224",
+ *   "KECCAK-256",
+ *   "KECCAK-384",
+ *   "KECCAK-512",
+ *   "SHA-384",
+ *   "SHA3-224",
+ *   "SHA3-256",
+ *   "SHA3-384",
+ *   "SHA3-512",
+ *   "SHAKE128",
+ *   "SHAKE256",
+ *   "TIGER",
+ *   // insecure (length-extendable):
+ *   "RIPEMD-160",
+ *   "SHA-224",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (collidable and length-extendable):
+ *   "MD5",
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * ## Timing safe comparison
+ *
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * [w3c/webcrypto#270](https://github.com/w3c/webcrypto/issues/270)), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const c = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello deno"),
+ * );
+ *
+ * assert(crypto.subtle.timingSafeEqual(a, b));
+ * assert(!crypto.subtle.timingSafeEqual(a, c));
+ * ```
+ *
+ * In addition to the method being part of the `crypto.subtle` interface, it is
+ * also loadable directly:
+ *
+ * ```ts
+ * import { timingSafeEqual } from "https://deno.land/std@$STD_VERSION/crypto/timing_safe_equal.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * // This will delegate to the runtime's WebCrypto implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "SHA-384",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ *
+ * // This will use a bundled Wasm/Rust implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "BLAKE3",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * @example Convert hash to a string
+ *
+ * ```ts
+ * import {
+ *   crypto,
+ *   toHashString,
+ * } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * const hash = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("You hear that Mr. Anderson?"),
+ * );
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ *
  * @module
  */
 const dntShim = __importStar(require("../../../../_dnt.shims.js"));

package/script/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/base64.js

@@ -8,6 +8,23 @@ exports.decode = exports.encode = void 0;
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64.ts";
+ *
+ * const b64Repr = "Zm9vYg==";
+ *
+ * const binaryData = decode(b64Repr);
+ * console.log(binaryData);
+ * // => Uint8Array [ 102, 111, 111, 98 ]
+ *
+ * console.log(encode(binaryData));
+ * // => Zm9vYg==
+ * ```
+ *
  * @module
  */
 const base64abc = [

package/script/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/base64url.js

@@ -31,6 +31,22 @@ exports.decode = exports.encode = void 0;
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/base64url.ts";
+ *
+ * const binary = new TextEncoder().encode("foobar");
+ * const encoded = encode(binary);
+ * console.log(encoded);
+ * // => "Zm9vYmFy"
+ *
+ * console.log(decode(encoded));
+ * // => Uint8Array(6) [ 102, 111, 111, 98, 97, 114 ]
+ * ```
+ *
  * @module
  */
 const base64 = __importStar(require("./base64.js"));

package/script/deps/deno.land/{std@0.164.0 → std@0.167.0}/encoding/hex.js

@@ -10,6 +10,22 @@ exports.decode = exports.encode = void 0;
  *
  * This module is browser compatible.
  *
+ * @example
+ * ```ts
+ * import {
+ *   decode,
+ *   encode,
+ * } from "https://deno.land/std@$STD_VERSION/encoding/hex.ts";
+ *
+ * const binary = new TextEncoder().encode("abc");
+ * const encoded = encode(binary);
+ * console.log(encoded);
+ * // => Uint8Array(6) [ 54, 49, 54, 50, 54, 51 ]
+ *
+ * console.log(decode(encoded));
+ * // => Uint8Array(3) [ 97, 98, 99 ]
+ * ```
+ *
  * @module
  */
 const hexTable = new TextEncoder().encode("0123456789abcdef");

package/script/pkg/receiver.js

@@ -78,7 +78,7 @@ class Receiver {
             console.log({ now, exp: p.exp });
             throw new SignatureError("token has expired");
         }
-        if (now - (req.clockTolerance ?? 0) < p.nbf) {
+        if (now + (req.clockTolerance ?? 0) < p.nbf) {
             throw new SignatureError("token is not yet valid");
         }
         const bodyHash = await this.subtleCrypto.digest("SHA-256", typeof req.body === "string"

package/types/deps/deno.land/{std@0.164.0 → std@0.167.0}/crypto/keystack.d.ts

@@ -9,8 +9,7 @@ export declare type Key = string | number[] | ArrayBuffer | Uint8Array;
  *
  * This was inspired by [keygrip](https://github.com/crypto-utils/keygrip/).
  *
- * ### Example
- *
+ * @example
  * ```ts
  * import { KeyStack } from "https://deno.land/std@$STD_VERSION/crypto/keystack.ts";
  *

package/types/deps/deno.land/std@0.167.0/crypto/mod.d.ts

@@ -0,0 +1,206 @@
+/**
+ * Extensions to the
+ * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+ * supporting additional encryption APIs, but also delegating to the built-in
+ * APIs when possible.
+ *
+ * Provides additional digest algorithms that are not part of the WebCrypto
+ * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
+ * also provides a `subtle.timingSafeEqual()` method to compare array buffers
+ * or data views in a way that isn't prone to timing based attacks.
+ *
+ * The "polyfill" delegates to `WebCrypto` where possible.
+ *
+ * The {@linkcode KeyStack} export implements the {@linkcode KeyRing} interface
+ * for managing rotatable keys for signing data to prevent tampering, like with
+ * HTTP cookies.
+ *
+ * ## Supported algorithms
+ *
+ * Here is a list of supported algorithms. If the algorithm name in WebCrypto
+ * and Wasm/Rust is the same, this library prefers to use algorithms that are
+ * supported by WebCrypto.
+ *
+ * WebCrypto
+ *
+ * ```ts
+ * // https://deno.land/std/crypto/mod.ts
+ * const webCryptoDigestAlgorithms = [
+ *   "SHA-384",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (length-extendable and collidable):
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * Wasm/Rust
+ *
+ * ```ts
+ * // https://deno.land/std/_wasm_crypto/mod.ts
+ * export const digestAlgorithms = [
+ *   "BLAKE2B-256",
+ *   "BLAKE2B-384",
+ *   "BLAKE2B",
+ *   "BLAKE2S",
+ *   "BLAKE3",
+ *   "KECCAK-224",
+ *   "KECCAK-256",
+ *   "KECCAK-384",
+ *   "KECCAK-512",
+ *   "SHA-384",
+ *   "SHA3-224",
+ *   "SHA3-256",
+ *   "SHA3-384",
+ *   "SHA3-512",
+ *   "SHAKE128",
+ *   "SHAKE256",
+ *   "TIGER",
+ *   // insecure (length-extendable):
+ *   "RIPEMD-160",
+ *   "SHA-224",
+ *   "SHA-256",
+ *   "SHA-512",
+ *   // insecure (collidable and length-extendable):
+ *   "MD5",
+ *   "SHA-1",
+ * ] as const;
+ * ```
+ *
+ * ## Timing safe comparison
+ *
+ * When checking the values of cryptographic hashes are equal, default
+ * comparisons can be susceptible to timing based attacks, where attacker is
+ * able to find out information about the host system by repeatedly checking
+ * response times to equality comparisons of values.
+ *
+ * It is likely some form of timing safe equality will make its way to the
+ * WebCrypto standard (see:
+ * [w3c/webcrypto#270](https://github.com/w3c/webcrypto/issues/270)), but until
+ * that time, `timingSafeEqual()` is provided:
+ *
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const c = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello deno"),
+ * );
+ *
+ * assert(crypto.subtle.timingSafeEqual(a, b));
+ * assert(!crypto.subtle.timingSafeEqual(a, c));
+ * ```
+ *
+ * In addition to the method being part of the `crypto.subtle` interface, it is
+ * also loadable directly:
+ *
+ * ```ts
+ * import { timingSafeEqual } from "https://deno.land/std@$STD_VERSION/crypto/timing_safe_equal.ts";
+ * import { assert } from "https://deno.land/std@$STD_VERSION/testing/asserts.ts";
+ *
+ * const a = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ * const b = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("hello world"),
+ * );
+ *
+ * assert(timingSafeEqual(a, b));
+ * ```
+ *
+ * @example
+ * ```ts
+ * import { crypto } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * // This will delegate to the runtime's WebCrypto implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "SHA-384",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ *
+ * // This will use a bundled Wasm/Rust implementation.
+ * console.log(
+ *   new Uint8Array(
+ *     await crypto.subtle.digest(
+ *       "BLAKE3",
+ *       new TextEncoder().encode("hello world"),
+ *     ),
+ *   ),
+ * );
+ * ```
+ *
+ * @example Convert hash to a string
+ *
+ * ```ts
+ * import {
+ *   crypto,
+ *   toHashString,
+ * } from "https://deno.land/std@$STD_VERSION/crypto/mod.ts";
+ *
+ * const hash = await crypto.subtle.digest(
+ *   "SHA-384",
+ *   new TextEncoder().encode("You hear that Mr. Anderson?"),
+ * );
+ *
+ * // Hex encoding by default
+ * console.log(toHashString(hash));
+ *
+ * // Or with base64 encoding
+ * console.log(toHashString(hash, "base64"));
+ * ```
+ *
+ * @module
+ */
+import * as dntShim from "../../../../_dnt.shims.js";
+import { DigestAlgorithm as WasmDigestAlgorithm } from "./_wasm/mod.js";
+export { type Data, type Key, KeyStack } from "./keystack.js";
+export { toHashString } from "./util.js";
+/** Extensions to the web standard `SubtleCrypto` interface. */
+export interface StdSubtleCrypto extends dntShim.SubtleCrypto {
+    /**
+     * Returns a new `Promise` object that will digest `data` using the specified
+     * `AlgorithmIdentifier`.
+     */
+    digest(algorithm: DigestAlgorithm, data: dntShim.BufferSource | AsyncIterable<dntShim.BufferSource> | Iterable<dntShim.BufferSource>): Promise<ArrayBuffer>;
+    /**
+     * Returns a ArrayBuffer with the result of digesting `data` using the
+     * specified `AlgorithmIdentifier`.
+     */
+    digestSync(algorithm: DigestAlgorithm, data: dntShim.BufferSource | Iterable<dntShim.BufferSource>): ArrayBuffer;
+    /** Compare to array buffers or data views in a way that timing based attacks
+     * cannot gain information about the platform. */
+    timingSafeEqual(a: ArrayBufferLike | DataView, b: ArrayBufferLike | DataView): boolean;
+}
+/** Extensions to the Web {@linkcode Crypto} interface. */
+export interface StdCrypto extends dntShim.Crypto {
+    readonly subtle: StdSubtleCrypto;
+}
+/**
+ * An wrapper for WebCrypto adding support for additional non-standard
+ * algorithms, but delegating to the runtime WebCrypto implementation whenever
+ * possible.
+ */
+declare const stdCrypto: StdCrypto;
+export declare type FNVAlgorithms = "FNV32" | "FNV32A" | "FNV64" | "FNV64A";
+export declare type DigestAlgorithmName = WasmDigestAlgorithm | FNVAlgorithms;
+export declare type DigestAlgorithmObject = {
+    name: DigestAlgorithmName;
+    length?: number;
+};
+export declare type DigestAlgorithm = DigestAlgorithmName | DigestAlgorithmObject;
+export { stdCrypto as crypto };

package/types/pkg/client/messages.d.ts

@@ -38,7 +38,7 @@ export declare type ListTasksRequest = {
 };
 export declare type ListTasksResponse = {
     cursor?: number;
-    logs: Task[];
+    tasks: Task[];
 };
 export declare class Messages {
     private readonly http;

package/types/pkg/receiver.d.ts

@@ -1,4 +1,4 @@
-import { crypto } from "../deps/deno.land/std@0.164.0/crypto/mod.js";
+import { crypto } from "../deps/deno.land/std@0.167.0/crypto/mod.js";
 export declare type SubtleCrypto = typeof crypto.subtle;
 /**
  * Necessary to verify the signature of a request.

package/types/deps/deno.land/std@0.164.0/crypto/mod.d.ts

@@ -1,56 +0,0 @@
-/**
- * Extensions to the
- * [Web Crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
- * supporting additional encryption APIs.
- *
- * Provides additional digest algorithms that are not part of the WebCrypto
- * standard as well as a `subtle.digest` and `subtle.digestSync` methods. It
- * also provide a `subtle.timingSafeEqual()` method to compare array buffers
- * or data views in a way that isn't prone to timing based attacks.
- *
- * The "polyfill" delegates to `WebCrypto` where possible.
- *
- * The {@linkcode KeyStack} export implements the {@linkcode KeyRing} interface
- * for managing rotatable keys for signing data to prevent tampering, like with
- * HTTP cookies.
- *
- * @module
- */
-import * as dntShim from "../../../../_dnt.shims.js";
-import { DigestAlgorithm as WasmDigestAlgorithm } from "./_wasm/mod.js";
-export { type Data, type Key, KeyStack } from "./keystack.js";
-export { toHashString } from "./util.js";
-/** Extensions to the web standard `SubtleCrypto` interface. */
-export interface StdSubtleCrypto extends dntShim.SubtleCrypto {
-    /**
-     * Returns a new `Promise` object that will digest `data` using the specified
-     * `AlgorithmIdentifier`.
-     */
-    digest(algorithm: DigestAlgorithm, data: dntShim.BufferSource | AsyncIterable<dntShim.BufferSource> | Iterable<dntShim.BufferSource>): Promise<ArrayBuffer>;
-    /**
-     * Returns a ArrayBuffer with the result of digesting `data` using the
-     * specified `AlgorithmIdentifier`.
-     */
-    digestSync(algorithm: DigestAlgorithm, data: dntShim.BufferSource | Iterable<dntShim.BufferSource>): ArrayBuffer;
-    /** Compare to array buffers or data views in a way that timing based attacks
-     * cannot gain information about the platform. */
-    timingSafeEqual(a: ArrayBufferLike | DataView, b: ArrayBufferLike | DataView): boolean;
-}
-/** Extensions to the Web {@linkcode Crypto} interface. */
-export interface StdCrypto extends dntShim.Crypto {
-    readonly subtle: StdSubtleCrypto;
-}
-/**
- * An wrapper for WebCrypto adding support for additional non-standard
- * algorithms, but delegating to the runtime WebCrypto implementation whenever
- * possible.
- */
-declare const stdCrypto: StdCrypto;
-export declare type FNVAlgorithms = "FNV32" | "FNV32A" | "FNV64" | "FNV64A";
-export declare type DigestAlgorithmName = WasmDigestAlgorithm | FNVAlgorithms;
-export declare type DigestAlgorithmObject = {
-    name: DigestAlgorithmName;
-    length?: number;
-};
-export declare type DigestAlgorithm = DigestAlgorithmName | DigestAlgorithmObject;
-export { stdCrypto as crypto };