hooklatch 0.0.0-stage → 1.0.0

package/dist/cjs/providers/linear.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linearDescriptor = void 0;
+const shared_js_1 = require("./shared.cjs");
+const SIGNATURE_HEADER = 'linear-signature';
+/**
+ * Linear webhook signature authentication: `Linear-Signature` is a single
+ * 64-character hex HMAC-SHA256 over the exact visible raw request body, keyed
+ * with the literal, untrimmed UTF-8 webhook secret. Missing or trim-blank values
+ * are `missing-signature`; prefixes, outer whitespace, commas, lists, non-hex,
+ * wrong length and all other nonconforming values fail closed as
+ * `malformed-signature`. Either hex case is accepted as Hooklatch receiver
+ * policy, not as a claim of exact Linear SDK parity.
+ *
+ * `Linear-Delivery`, `Linear-Event`, `linear-timestamp` and all alien
+ * authentication headers are outside the MAC. They cannot establish freshness or
+ * trusted identity. Every identity field is null and `authenticatedFields` is
+ * empty: this descriptor intentionally performs body-only authentication, does
+ * not parse JSON, and never derives identity or time from body content. Old or
+ * future unsigned timestamps therefore cannot change authenticity, and this
+ * descriptor does not provide replay protection or business idempotency.
+ *
+ * The secret is literal UTF-8 with no prefix stripping, Base64 decoding,
+ * trimming or inferred length bound. Empty secrets are invalid configuration;
+ * whitespace-only and non-ASCII secrets remain literal keys. The exact raw body
+ * bytes are returned as signed content, so callers must retain the received
+ * bytes rather than reserialize parsed JSON.
+ *
+ * Sources:
+ * - https://linear.app/developers/webhooks
+ * - https://linear.app/developers/sdk-webhooks
+ * - https://github.com/linear/linear/blob/4d9cdbf0beb1d1da1824deb5ff3cd458c71380c9/packages/sdk/src/webhooks/client.ts
+ *
+ * No Linear-published signature tuple is claimed; test anchors are synthetic.
+ */
+exports.linearDescriptor = {
+    provider: 'linear',
+    decodeSecret(secret) {
+        return (0, shared_js_1.decodeLiteralSecret)(secret, 'Linear');
+    },
+    parse(headers, rawBody) {
+        const raw = headers.get(SIGNATURE_HEADER);
+        if (raw === undefined || raw.trim() === '') {
+            return (0, shared_js_1.failure)('missing-signature', 'No Linear signature header was provided.');
+        }
+        const signature = (0, shared_js_1.decodeHexSignature)(raw);
+        if (signature === null) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Linear signature header is malformed.');
+        }
+        const identity = {
+            deliveryId: null,
+            eventId: null,
+            timestamp: null,
+            authenticatedFields: [],
+        };
+        return { ok: true, signatures: [signature], signedContent: rawBody, identity };
+    },
+};

package/dist/cjs/providers/linear.d.cts

@@ -0,0 +1,36 @@
+import type { NormalizedHeaders, ParseResult } from '../internal/provider.cjs';
+/**
+ * Linear webhook signature authentication: `Linear-Signature` is a single
+ * 64-character hex HMAC-SHA256 over the exact visible raw request body, keyed
+ * with the literal, untrimmed UTF-8 webhook secret. Missing or trim-blank values
+ * are `missing-signature`; prefixes, outer whitespace, commas, lists, non-hex,
+ * wrong length and all other nonconforming values fail closed as
+ * `malformed-signature`. Either hex case is accepted as Hooklatch receiver
+ * policy, not as a claim of exact Linear SDK parity.
+ *
+ * `Linear-Delivery`, `Linear-Event`, `linear-timestamp` and all alien
+ * authentication headers are outside the MAC. They cannot establish freshness or
+ * trusted identity. Every identity field is null and `authenticatedFields` is
+ * empty: this descriptor intentionally performs body-only authentication, does
+ * not parse JSON, and never derives identity or time from body content. Old or
+ * future unsigned timestamps therefore cannot change authenticity, and this
+ * descriptor does not provide replay protection or business idempotency.
+ *
+ * The secret is literal UTF-8 with no prefix stripping, Base64 decoding,
+ * trimming or inferred length bound. Empty secrets are invalid configuration;
+ * whitespace-only and non-ASCII secrets remain literal keys. The exact raw body
+ * bytes are returned as signed content, so callers must retain the received
+ * bytes rather than reserialize parsed JSON.
+ *
+ * Sources:
+ * - https://linear.app/developers/webhooks
+ * - https://linear.app/developers/sdk-webhooks
+ * - https://github.com/linear/linear/blob/4d9cdbf0beb1d1da1824deb5ff3cd458c71380c9/packages/sdk/src/webhooks/client.ts
+ *
+ * No Linear-published signature tuple is claimed; test anchors are synthetic.
+ */
+export declare const linearDescriptor: {
+    provider: "linear";
+    decodeSecret(secret: string): Uint8Array;
+    parse(headers: NormalizedHeaders, rawBody: Uint8Array): ParseResult;
+};

package/dist/cjs/providers/paddle.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paddleDescriptor = void 0;
+const bytes_js_1 = require("../internal/bytes.cjs");
+const shared_js_1 = require("./shared.cjs");
+const SIGNATURE_HEADER = 'paddle-signature';
+const TIMESTAMP_KEY = 'ts';
+const SIGNATURE_KEY = 'h1';
+/**
+ * Opaque nonempty printable ASCII unknown-field value: no whitespace, commas,
+ * semicolons, or additional equals signs. This is a bounded Hooklatch grammar,
+ * not a promise to support an unspecified future signature version.
+ */
+const OPAQUE_VALUE = /^[\x21-\x2b\x2d-\x3a\x3c\x3e-\x7e]+$/;
+/**
+ * Paddle Billing: `Paddle-Signature: ts=<unix seconds>;h1=<64 hex>`.
+ * The signature covers the exact `ts` text, a colon, and the untouched raw
+ * body. Repeated `h1` values are a Hooklatch rotation accept-set; every `h1`
+ * must be valid. Unknown fields such as `h2` are validated then ignored.
+ * Freshness is enforced by core, never here.
+ * Source: https://developer.paddle.com/webhooks/about/signature-verification/
+ */
+exports.paddleDescriptor = {
+    provider: 'paddle',
+    decodeSecret(secret) {
+        return (0, shared_js_1.decodeLiteralSecret)(secret, 'Paddle');
+    },
+    parse(headers, rawBody) {
+        const raw = headers.get(SIGNATURE_HEADER);
+        if (raw === undefined || raw.trim() === '') {
+            return (0, shared_js_1.failure)('missing-signature', 'No Paddle signature header was provided.');
+        }
+        // HTTP comma-combined duplicate header values never form a valid field list.
+        if (raw.includes(',')) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+        }
+        const signatures = [];
+        let timestampText;
+        let timestampCount = 0;
+        let unknownSchemes = 0;
+        for (const rawSegment of raw.split(';')) {
+            // Trim outer segment whitespace only; keys and values stay exact.
+            const segment = rawSegment.trim();
+            if (segment === '') {
+                return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+            }
+            // Reject missing keys, empty values, and extra equals signs.
+            const separator = segment.indexOf('=');
+            if (separator <= 0 || separator === segment.length - 1 || segment.indexOf('=', separator + 1) !== -1) {
+                return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+            }
+            const key = segment.slice(0, separator);
+            const value = segment.slice(separator + 1);
+            if (!(0, shared_js_1.isSchemeToken)(key)) {
+                return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+            }
+            if (key === TIMESTAMP_KEY) {
+                timestampCount += 1;
+                if (timestampCount > 1) {
+                    return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+                }
+                if (!(0, shared_js_1.isCanonicalTimestamp)(value)) {
+                    return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+                }
+                timestampText = value;
+                continue;
+            }
+            if (key === SIGNATURE_KEY) {
+                const decoded = (0, shared_js_1.decodeHexSignature)(value);
+                // One malformed h1 poisons the whole header, even beside a valid h1.
+                if (decoded === null) {
+                    return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+                }
+                signatures.push(decoded);
+                continue;
+            }
+            // Unknown fields are structurally validated, then ignored.
+            if (!OPAQUE_VALUE.test(value)) {
+                return (0, shared_js_1.failure)('malformed-signature', 'The Paddle signature header is malformed.');
+            }
+            unknownSchemes += 1;
+        }
+        // Required-field checks run only after all structure/token validation.
+        if (signatures.length === 0) {
+            return unknownSchemes > 0
+                ? (0, shared_js_1.failure)('unsupported-scheme', 'No supported Paddle signature scheme was provided.')
+                : (0, shared_js_1.failure)('missing-signature', 'No Paddle signature value was provided.');
+        }
+        if (timestampText === undefined) {
+            return (0, shared_js_1.failure)('missing-timestamp', 'No Paddle timestamp was provided.');
+        }
+        const identity = {
+            deliveryId: null,
+            eventId: null,
+            timestamp: Number(timestampText),
+            authenticatedFields: ['timestamp'],
+        };
+        return {
+            ok: true,
+            signatures,
+            signedContent: (0, bytes_js_1.concatBytes)((0, bytes_js_1.utf8)(`${timestampText}:`), rawBody),
+            identity,
+        };
+    },
+};

package/dist/cjs/providers/paddle.d.cts

@@ -0,0 +1,14 @@
+import type { NormalizedHeaders, ParseResult } from '../internal/provider.cjs';
+/**
+ * Paddle Billing: `Paddle-Signature: ts=<unix seconds>;h1=<64 hex>`.
+ * The signature covers the exact `ts` text, a colon, and the untouched raw
+ * body. Repeated `h1` values are a Hooklatch rotation accept-set; every `h1`
+ * must be valid. Unknown fields such as `h2` are validated then ignored.
+ * Freshness is enforced by core, never here.
+ * Source: https://developer.paddle.com/webhooks/about/signature-verification/
+ */
+export declare const paddleDescriptor: {
+    provider: "paddle";
+    decodeSecret(secret: string): Uint8Array;
+    parse(headers: NormalizedHeaders, rawBody: Uint8Array): ParseResult;
+};

package/dist/cjs/providers/polar.cjs

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolarDescriptor = createPolarDescriptor;
+const errors_js_1 = require("../errors.cjs");
+const shared_js_1 = require("./shared.cjs");
+const standard_webhooks_protocol_js_1 = require("./standard-webhooks-protocol.cjs");
+const CANONICAL_HEADERS = {
+    id: 'webhook-id',
+    timestamp: 'webhook-timestamp',
+    signature: 'webhook-signature',
+};
+const currentDescriptor = (0, standard_webhooks_protocol_js_1.createStandardWebhooksProtocol)('polar', 'Polar', CANONICAL_HEADERS);
+const legacyDescriptor = {
+    provider: 'polar',
+    decodeSecret(secret) {
+        return (0, shared_js_1.decodeLiteralSecret)(secret, 'Polar');
+    },
+    parse: currentDescriptor.parse,
+};
+function invalidOptions() {
+    throw new errors_js_1.HooklatchError('invalid-options', 'Invalid Polar provider options.');
+}
+function isConfigObject(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    try {
+        return !Array.isArray(value);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read the selected mode as an own field and snapshot it before returning the
+ * descriptor. Inherited fields are not configuration; an own `secretMode:
+ * undefined` is invalid rather than an omitted optional field.
+ */
+function snapshotSecretMode(options) {
+    if (options === undefined)
+        return 'current';
+    if (!isConfigObject(options))
+        invalidOptions();
+    let keys = [];
+    let hasMode = false;
+    let mode = undefined;
+    try {
+        keys = Reflect.ownKeys(options).filter((key) => Object.getOwnPropertyDescriptor(options, key)?.enumerable);
+        hasMode = Object.hasOwn(options, 'secretMode');
+        mode = hasMode ? options.secretMode : undefined;
+    }
+    catch {
+        invalidOptions();
+    }
+    if (keys.some((key) => key !== 'secretMode'))
+        invalidOptions();
+    if (!hasMode)
+        return 'current';
+    if (mode !== 'current' && mode !== 'legacy')
+        invalidOptions();
+    return mode;
+}
+/**
+ * Polar webhooks use the canonical Standard Webhooks headers and signed
+ * content: `${webhook-id}.${webhook-timestamp}.${rawBody}`.
+ *
+ * `current` (the default) keeps the shared Standard Webhooks decoder: an
+ * optional `whsec_` prefix is removed and the remainder must decode as
+ * canonical Base64 to 24..64 bytes. `legacy` treats the complete secret string
+ * as literal UTF-8 bytes, including any `whsec_` prefix, with only the shared
+ * nonempty policy. Exactly one mode applies to every secret configured for the
+ * descriptor; there is no prefix inference or cross-mode fallback.
+ *
+ * Polar's SDK tries both key interpretations and floors fractional timestamps.
+ * Hooklatch deliberately does neither, and does not decode opaque bodies as
+ * text. Source:
+ * https://raw.githubusercontent.com/polarsource/polar/89917ad4fe752b06ff84bd31c313d2a53a6085f1/sdk/typescript/src/webhooks.ts
+ */
+function createPolarDescriptor(options) {
+    return snapshotSecretMode(options) === 'current' ? currentDescriptor : legacyDescriptor;
+}

package/dist/cjs/providers/polar.d.cts

@@ -0,0 +1,25 @@
+import type { ProviderDescriptor } from '../internal/provider.cjs';
+export interface PolarDescriptorOptions {
+    readonly secretMode?: 'current' | 'legacy';
+}
+type PolarDescriptor = {
+    readonly provider: 'polar';
+} & Pick<ProviderDescriptor, 'decodeSecret' | 'parse'>;
+/**
+ * Polar webhooks use the canonical Standard Webhooks headers and signed
+ * content: `${webhook-id}.${webhook-timestamp}.${rawBody}`.
+ *
+ * `current` (the default) keeps the shared Standard Webhooks decoder: an
+ * optional `whsec_` prefix is removed and the remainder must decode as
+ * canonical Base64 to 24..64 bytes. `legacy` treats the complete secret string
+ * as literal UTF-8 bytes, including any `whsec_` prefix, with only the shared
+ * nonempty policy. Exactly one mode applies to every secret configured for the
+ * descriptor; there is no prefix inference or cross-mode fallback.
+ *
+ * Polar's SDK tries both key interpretations and floors fractional timestamps.
+ * Hooklatch deliberately does neither, and does not decode opaque bodies as
+ * text. Source:
+ * https://raw.githubusercontent.com/polarsource/polar/89917ad4fe752b06ff84bd31c313d2a53a6085f1/sdk/typescript/src/webhooks.ts
+ */
+export declare function createPolarDescriptor(options?: PolarDescriptorOptions): PolarDescriptor;
+export {};

package/dist/cjs/providers/razorpay.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.razorpayDescriptor = void 0;
+const shared_js_1 = require("./shared.cjs");
+const SIGNATURE_HEADER = 'x-razorpay-signature';
+const EVENT_ID_HEADER = 'x-razorpay-event-id';
+/**
+ * Razorpay `X-Razorpay-Signature`: a single hex HMAC-SHA256 over the raw request
+ * body only, keyed with the literal dashboard webhook secret. A missing,
+ * blank, prefixed, non-hex, wrong-length or comma-combined value fails closed.
+ * The optional `x-razorpay-event-id` is unsigned metadata and never proves
+ * authenticity.
+ *
+ * Sources:
+ * - https://razorpay.com/docs/webhooks/validate-test/
+ * - https://github.com/razorpay/razorpay-node/blob/b9e8527225a7322ba2671a3bc0b848fd019d2d8c/lib/utils/razorpay-utils.js
+ *
+ * No Razorpay-published signature vector is claimed; test anchors are synthetic.
+ */
+exports.razorpayDescriptor = {
+    provider: 'razorpay',
+    decodeSecret(secret) {
+        return (0, shared_js_1.decodeLiteralSecret)(secret, 'Razorpay');
+    },
+    parse(headers, rawBody) {
+        const raw = headers.get(SIGNATURE_HEADER);
+        if (raw === undefined || raw.trim() === '') {
+            return (0, shared_js_1.failure)('missing-signature', 'No Razorpay signature header was provided.');
+        }
+        const signature = (0, shared_js_1.decodeHexSignature)(raw);
+        if (signature === null) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Razorpay signature header is malformed.');
+        }
+        const eventId = headers.get(EVENT_ID_HEADER);
+        const identity = {
+            deliveryId: null,
+            eventId: eventId === undefined || eventId.trim() === '' ? null : eventId,
+            timestamp: null,
+            authenticatedFields: [],
+        };
+        return { ok: true, signatures: [signature], signedContent: rawBody, identity };
+    },
+};

package/dist/cjs/providers/razorpay.d.cts

@@ -0,0 +1,19 @@
+import type { NormalizedHeaders, ParseResult } from '../internal/provider.cjs';
+/**
+ * Razorpay `X-Razorpay-Signature`: a single hex HMAC-SHA256 over the raw request
+ * body only, keyed with the literal dashboard webhook secret. A missing,
+ * blank, prefixed, non-hex, wrong-length or comma-combined value fails closed.
+ * The optional `x-razorpay-event-id` is unsigned metadata and never proves
+ * authenticity.
+ *
+ * Sources:
+ * - https://razorpay.com/docs/webhooks/validate-test/
+ * - https://github.com/razorpay/razorpay-node/blob/b9e8527225a7322ba2671a3bc0b848fd019d2d8c/lib/utils/razorpay-utils.js
+ *
+ * No Razorpay-published signature vector is claimed; test anchors are synthetic.
+ */
+export declare const razorpayDescriptor: {
+    provider: "razorpay";
+    decodeSecret(secret: string): Uint8Array;
+    parse(headers: NormalizedHeaders, rawBody: Uint8Array): ParseResult;
+};

package/dist/cjs/providers/replicate.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replicateDescriptor = void 0;
+const standard_webhooks_protocol_js_1 = require("./standard-webhooks-protocol.cjs");
+/**
+ * Replicate webhooks use the canonical Standard Webhooks `webhook-id`,
+ * `webhook-timestamp` and `webhook-signature` headers. The secret is
+ * Base64-decoded (an optional `whsec_` prefix is stripped) and must decode to
+ * 24-64 bytes; the signature covers the exact
+ * `${webhook-id}.${webhook-timestamp}.` bytes followed by the raw body.
+ *
+ * These headers authenticate protocol bytes, not a unique Replicate identity.
+ * A signature minted by another canonical alias verifies here when the same
+ * secret is configured, so use endpoint-specific secrets. No prediction or
+ * event payload is parsed and no resource id is inferred.
+ *
+ * No Replicate-published signature vector is claimed; the direct tests use
+ * synthetic anchors. Source:
+ * https://replicate.com/docs/topics/webhooks/verify-webhook
+ */
+exports.replicateDescriptor = (0, standard_webhooks_protocol_js_1.createStandardWebhooksProtocol)('replicate', 'Replicate', {
+    id: 'webhook-id',
+    timestamp: 'webhook-timestamp',
+    signature: 'webhook-signature',
+});

package/dist/cjs/providers/replicate.d.cts

@@ -0,0 +1,19 @@
+/**
+ * Replicate webhooks use the canonical Standard Webhooks `webhook-id`,
+ * `webhook-timestamp` and `webhook-signature` headers. The secret is
+ * Base64-decoded (an optional `whsec_` prefix is stripped) and must decode to
+ * 24-64 bytes; the signature covers the exact
+ * `${webhook-id}.${webhook-timestamp}.` bytes followed by the raw body.
+ *
+ * These headers authenticate protocol bytes, not a unique Replicate identity.
+ * A signature minted by another canonical alias verifies here when the same
+ * secret is configured, so use endpoint-specific secrets. No prediction or
+ * event payload is parsed and no resource id is inferred.
+ *
+ * No Replicate-published signature vector is claimed; the direct tests use
+ * synthetic anchors. Source:
+ * https://replicate.com/docs/topics/webhooks/verify-webhook
+ */
+export declare const replicateDescriptor: {
+    readonly provider: "replicate";
+} & Pick<import("../internal/provider.cjs").ProviderDescriptor, "decodeSecret" | "parse">;

package/dist/cjs/providers/sanity.cjs

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanityDescriptor = void 0;
+const bytes_js_1 = require("../internal/bytes.cjs");
+const shared_js_1 = require("./shared.cjs");
+const SIGNATURE_HEADER = 'sanity-webhook-signature';
+const TIMESTAMP_FIELD = 't=';
+const SIGNATURE_FIELD = 'v1=';
+const DIGEST_CHARACTERS = 43;
+const BASE64URL_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+/**
+ * Sanity does not send signed payloads before 2021-01-01T00:00:00.000Z, so a
+ * millisecond timestamp below this bound is not a Sanity delivery. The bound
+ * mirrors the reference toolkit; the failure code is Hooklatch policy.
+ */
+const MINIMUM_TIMESTAMP_MS = 1609459200000;
+/**
+ * Split the exact accepted header grammar `t=<ms>,v1=<digest>`.
+ *
+ * The fields are ordered, appear exactly once, and carry no whitespace, extra
+ * fields, duplicate fields, semicolon separators, or alternate versions. Any
+ * other structure is rejected instead of being repaired.
+ */
+function splitHeader(raw) {
+    const separator = raw.indexOf(',');
+    if (separator < 0)
+        return null;
+    const timestampField = raw.slice(0, separator);
+    const signatureField = raw.slice(separator + 1);
+    if (!timestampField.startsWith(TIMESTAMP_FIELD))
+        return null;
+    if (!signatureField.startsWith(SIGNATURE_FIELD))
+        return null;
+    const timestampText = timestampField.slice(TIMESTAMP_FIELD.length);
+    const digest = signatureField.slice(SIGNATURE_FIELD.length);
+    if (timestampText.length === 0)
+        return null;
+    return { timestampText, digest };
+}
+/**
+ * Encode the 32 decoded digest bytes as canonical unpadded Base64url.
+ *
+ * 32 bytes are 256 bits: 42 characters carry 252 of them and the last four
+ * bits close the 43rd character.
+ */
+function encodeBase64Url(bytes) {
+    let output = '';
+    let buffer = 0;
+    let bits = 0;
+    for (const byte of bytes) {
+        buffer = (buffer << 8) | byte;
+        bits += 8;
+        while (bits >= 6) {
+            bits -= 6;
+            output += BASE64URL_ALPHABET.charAt((buffer >>> bits) & 0x3f);
+            buffer &= (1 << bits) - 1;
+        }
+    }
+    return output + BASE64URL_ALPHABET.charAt((buffer << (6 - bits)) & 0x3f);
+}
+/**
+ * Decode exactly 43 canonical unpadded Base64url characters into 32 bytes.
+ *
+ * The 43 characters carry 258 bits, so 32 bytes consume 256 of them and the
+ * two remaining low bits of the final character are pad bits. Re-encoding the
+ * decoded bytes must reproduce the input exactly, which rejects a digest whose
+ * pad bits are not zero.
+ */
+function decodeBase64UrlDigest(value) {
+    if (value.length !== DIGEST_CHARACTERS)
+        return null;
+    const bytes = new Uint8Array(32);
+    let buffer = 0;
+    let bits = 0;
+    let offset = 0;
+    for (let index = 0; index < value.length; index += 1) {
+        const digit = BASE64URL_ALPHABET.indexOf(value.charAt(index));
+        if (digit < 0)
+            return null;
+        buffer = (buffer << 6) | digit;
+        bits += 6;
+        if (bits < 8)
+            continue;
+        bits -= 8;
+        bytes[offset] = (buffer >>> bits) & 0xff;
+        offset += 1;
+        buffer &= (1 << bits) - 1;
+    }
+    return encodeBase64Url(bytes) === value ? bytes : null;
+}
+/**
+ * Sanity: `sanity-webhook-signature: t=<unix milliseconds>,v1=<base64url>`.
+ *
+ * The HMAC-SHA256 covers UTF8(the original `t` text + ".") concatenated with
+ * the exact raw body. The secret is the literal, untrimmed UTF-8 text; it is
+ * never Base64-decoded. The digest is canonical unpadded Base64url for exactly
+ * 32 bytes, decoded by a descriptor-local decoder so the shared standard
+ * Base64 handling stays unchanged.
+ *
+ * The accepted header is exactly `t=<ms>,v1=<digest>`: ordered fields, one
+ * each, no whitespace anywhere or outer trimming, no extra or duplicate
+ * fields, no semicolon separators, no padding, and no alternate versions. A
+ * missing or blank header is `missing-signature`; every other nonmatching
+ * structure is `malformed-signature`, with no alternate reason precedence.
+ *
+ * `t` must be a canonical nonnegative safe decimal integer of milliseconds
+ * with no leading zeros, at or after 2021-01-01T00:00:00.000Z. Identity is
+ * `timestamp = Number(t) / 1000` with no delivery or event id; freshness is
+ * enforced by core and is never evaluated here.
+ *
+ * The reference SDK verifies UTF-8 text and refuses to sign an empty payload.
+ * This descriptor accepts empty, NUL, invalid UTF-8, and non-JSON bodies as
+ * opaque bytes, so it extends rather than matches that behavior, and it does
+ * not claim exact SDK parity or live interoperability. The strict grammar
+ * is checked at parse time. The reference decoder regex accepts spaces and
+ * trimming, but full SDK verification compares the original header to canonical
+ * re-encoding and also rejects these noncanonical header variants.
+ *
+ * Sources:
+ * - https://www.sanity.io/docs/content-lake/webhook-best-practices
+ * - https://github.com/sanity-io/webhook-toolkit/blob/e0c211ed6cd80465a70829e335c9e219f37839ba/src/signature.ts
+ */
+exports.sanityDescriptor = {
+    provider: 'sanity',
+    decodeSecret(secret) {
+        return (0, shared_js_1.decodeLiteralSecret)(secret, 'Sanity');
+    },
+    parse(headers, rawBody) {
+        const raw = headers.get(SIGNATURE_HEADER);
+        if (raw === undefined || raw.trim() === '') {
+            return (0, shared_js_1.failure)('missing-signature', 'No Sanity signature header was provided.');
+        }
+        const fields = splitHeader(raw);
+        if (fields === null) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Sanity signature header is malformed.');
+        }
+        if (!(0, shared_js_1.isCanonicalTimestamp)(fields.timestampText)) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Sanity signature header is malformed.');
+        }
+        const timestamp = Number(fields.timestampText);
+        if (timestamp < MINIMUM_TIMESTAMP_MS) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Sanity signature header is malformed.');
+        }
+        const digest = decodeBase64UrlDigest(fields.digest);
+        if (digest === null) {
+            return (0, shared_js_1.failure)('malformed-signature', 'The Sanity signature header is malformed.');
+        }
+        const identity = {
+            deliveryId: null,
+            eventId: null,
+            timestamp: timestamp / 1000,
+            authenticatedFields: ['timestamp'],
+        };
+        return {
+            ok: true,
+            signatures: [digest],
+            signedContent: (0, bytes_js_1.concatBytes)((0, bytes_js_1.utf8)(`${fields.timestampText}.`), rawBody),
+            identity,
+        };
+    },
+};

package/dist/cjs/providers/sanity.d.cts

@@ -0,0 +1,38 @@
+import type { NormalizedHeaders, ParseResult } from '../internal/provider.cjs';
+/**
+ * Sanity: `sanity-webhook-signature: t=<unix milliseconds>,v1=<base64url>`.
+ *
+ * The HMAC-SHA256 covers UTF8(the original `t` text + ".") concatenated with
+ * the exact raw body. The secret is the literal, untrimmed UTF-8 text; it is
+ * never Base64-decoded. The digest is canonical unpadded Base64url for exactly
+ * 32 bytes, decoded by a descriptor-local decoder so the shared standard
+ * Base64 handling stays unchanged.
+ *
+ * The accepted header is exactly `t=<ms>,v1=<digest>`: ordered fields, one
+ * each, no whitespace anywhere or outer trimming, no extra or duplicate
+ * fields, no semicolon separators, no padding, and no alternate versions. A
+ * missing or blank header is `missing-signature`; every other nonmatching
+ * structure is `malformed-signature`, with no alternate reason precedence.
+ *
+ * `t` must be a canonical nonnegative safe decimal integer of milliseconds
+ * with no leading zeros, at or after 2021-01-01T00:00:00.000Z. Identity is
+ * `timestamp = Number(t) / 1000` with no delivery or event id; freshness is
+ * enforced by core and is never evaluated here.
+ *
+ * The reference SDK verifies UTF-8 text and refuses to sign an empty payload.
+ * This descriptor accepts empty, NUL, invalid UTF-8, and non-JSON bodies as
+ * opaque bytes, so it extends rather than matches that behavior, and it does
+ * not claim exact SDK parity or live interoperability. The strict grammar
+ * is checked at parse time. The reference decoder regex accepts spaces and
+ * trimming, but full SDK verification compares the original header to canonical
+ * re-encoding and also rejects these noncanonical header variants.
+ *
+ * Sources:
+ * - https://www.sanity.io/docs/content-lake/webhook-best-practices
+ * - https://github.com/sanity-io/webhook-toolkit/blob/e0c211ed6cd80465a70829e335c9e219f37839ba/src/signature.ts
+ */
+export declare const sanityDescriptor: {
+    provider: "sanity";
+    decodeSecret(secret: string): Uint8Array;
+    parse(headers: NormalizedHeaders, rawBody: Uint8Array): ParseResult;
+};