@relaymessenger/chat-sdk-adapter 0.2.1 → 0.3.0-staging.1

package/dist/src/format.js

@@ -1,266 +0,0 @@
-import { parseMarkdown, tableToAscii } from "chat";
-/** Relay accepts at most 200 style ranges on one text part. */
-export const MAX_STYLE_RANGES = 200;
-function sameStyles(left, right) {
-    if (left.length !== right.length)
-        return false;
-    return left.every((style, index) => style === right[index]);
-}
-class TextBuilder {
-    out = "";
-    runs = [];
-    get length() {
-        return this.out.length;
-    }
-    append(value, styles) {
-        if (!value)
-            return;
-        const start = this.out.length;
-        this.out += value;
-        if (styles.length > 0) {
-            this.runs.push({ start, length: value.length, styles: [...styles] });
-        }
-    }
-    /** Splice an already-rendered fragment, rebasing its style offsets. */
-    appendRendered(rendered, styles) {
-        if (!rendered.text)
-            return;
-        const base = this.out.length;
-        this.out += rendered.text;
-        if (styles.length > 0) {
-            this.runs.push({
-                start: base,
-                length: rendered.text.length,
-                styles: [...styles],
-            });
-        }
-        for (const run of rendered.styles) {
-            this.runs.push({
-                start: base + run.start,
-                length: run.length,
-                styles: [...run.styles],
-            });
-        }
-    }
-    finish() {
-        return { text: this.out, styles: normalizeStyles(this.runs) };
-    }
-}
-/**
- * Collapse the raw run list into what Relay's contract requires: sorted by
- * start, non-overlapping, and no more than 200 entries. Nested emphasis
- * produces overlapping runs, so they are flattened onto a per-character style
- * set and then re-run-length-encoded.
- */
-export function normalizeStyles(runs) {
-    if (runs.length === 0)
-        return [];
-    let end = 0;
-    for (const run of runs)
-        end = Math.max(end, run.start + run.length);
-    const perCharacter = Array.from({ length: end }, () => []);
-    for (const run of runs) {
-        for (let i = run.start; i < run.start + run.length; i += 1) {
-            const slot = perCharacter[i];
-            if (!slot)
-                continue;
-            for (const style of run.styles) {
-                if (!slot.includes(style))
-                    slot.push(style);
-            }
-        }
-    }
-    const merged = [];
-    let index = 0;
-    while (index < end) {
-        const styles = perCharacter[index] ?? [];
-        if (styles.length === 0) {
-            index += 1;
-            continue;
-        }
-        let span = index + 1;
-        while (span < end && sameStyles(perCharacter[span] ?? [], styles))
-            span += 1;
-        merged.push({ start: index, length: span - index, styles: [...styles].sort() });
-        index = span;
-    }
-    // Styles are presentation only, so an overflowing document keeps every word
-    // and loses only the runs past Relay's ceiling.
-    return merged.slice(0, MAX_STYLE_RANGES);
-}
-/**
- * Insert a prefix at the start of every line, remapping style offsets so the
- * runs still cover the same characters.
- */
-export function prefixLines(rendered, prefix, firstPrefix = prefix) {
-    if (!rendered.text)
-        return { text: firstPrefix, styles: [] };
-    const map = new Array(rendered.text.length + 1);
-    let out = firstPrefix;
-    let atLineStart = false;
-    for (let i = 0; i < rendered.text.length; i += 1) {
-        if (atLineStart) {
-            out += prefix;
-            atLineStart = false;
-        }
-        map[i] = out.length;
-        const character = rendered.text[i];
-        out += character;
-        if (character === "\n")
-            atLineStart = true;
-    }
-    map[rendered.text.length] = out.length;
-    const styles = rendered.styles.map((run) => {
-        const start = map[run.start];
-        const stop = map[run.start + run.length];
-        return { start, length: stop - start, styles: run.styles };
-    });
-    return { text: out, styles };
-}
-function nodeText(node) {
-    if ("value" in node && typeof node.value === "string")
-        return node.value;
-    if ("children" in node && Array.isArray(node.children)) {
-        return node.children.map(nodeText).join("");
-    }
-    return "";
-}
-function renderInline(nodes, builder, styles) {
-    for (const node of nodes) {
-        switch (node.type) {
-            case "text":
-                builder.append(node.value, styles);
-                break;
-            case "strong":
-                renderInline(node.children, builder, [...styles, "bold"]);
-                break;
-            case "emphasis":
-                renderInline(node.children, builder, [...styles, "italic"]);
-                break;
-            case "delete":
-                renderInline(node.children, builder, [
-                    ...styles,
-                    "strikethrough",
-                ]);
-                break;
-            case "inlineCode":
-                builder.append(node.value, [...styles, "monospace"]);
-                break;
-            case "break":
-                builder.append("\n", []);
-                break;
-            case "link": {
-                const label = nodeText(node);
-                renderInline(node.children, builder, styles);
-                // Relay has no link style, so the destination is written out rather
-                // than dropped whenever the label does not already carry it.
-                if (node.url && node.url !== label)
-                    builder.append(` (${node.url})`, []);
-                break;
-            }
-            case "image": {
-                const alt = node.alt ?? "";
-                builder.append(alt ? `${alt} (${node.url})` : node.url, styles);
-                break;
-            }
-            case "html":
-                builder.append(node.value, styles);
-                break;
-            case "footnoteReference":
-                builder.append(`[^${node.identifier}]`, styles);
-                break;
-            default: {
-                if ("children" in node && Array.isArray(node.children)) {
-                    renderInline(node.children, builder, styles);
-                }
-                else if ("value" in node && typeof node.value === "string") {
-                    builder.append(node.value, styles);
-                }
-            }
-        }
-    }
-}
-function renderBlock(node) {
-    switch (node.type) {
-        case "paragraph": {
-            const builder = new TextBuilder();
-            renderInline(node.children, builder, []);
-            return builder.finish();
-        }
-        case "heading": {
-            const builder = new TextBuilder();
-            renderInline(node.children, builder, ["bold"]);
-            return builder.finish();
-        }
-        case "code": {
-            const builder = new TextBuilder();
-            builder.append(node.value, ["monospace"]);
-            return builder.finish();
-        }
-        case "blockquote": {
-            const inner = renderBlocks(node.children);
-            return prefixLines(inner, "> ");
-        }
-        case "list": {
-            const parts = [];
-            let counter = node.start ?? 1;
-            for (const item of node.children) {
-                const marker = node.ordered ? `${counter}. ` : "- ";
-                counter += 1;
-                const inner = item.type === "listItem"
-                    ? renderBlocks(item.children)
-                    : renderBlock(item);
-                parts.push(prefixLines(inner, " ".repeat(marker.length), marker));
-            }
-            return joinRendered(parts, "\n");
-        }
-        case "table":
-            return { text: tableToAscii(node), styles: [] };
-        case "thematicBreak":
-            return { text: "---", styles: [] };
-        case "html":
-            return { text: node.value, styles: [] };
-        default: {
-            const builder = new TextBuilder();
-            if ("children" in node && Array.isArray(node.children)) {
-                renderInline(node.children, builder, []);
-            }
-            else if ("value" in node && typeof node.value === "string") {
-                builder.append(node.value, []);
-            }
-            return builder.finish();
-        }
-    }
-}
-function joinRendered(parts, separator) {
-    const builder = new TextBuilder();
-    let first = true;
-    for (const part of parts) {
-        if (!part.text)
-            continue;
-        if (!first)
-            builder.append(separator, []);
-        builder.appendRendered(part, []);
-        first = false;
-    }
-    return builder.finish();
-}
-function renderBlocks(nodes) {
-    return joinRendered(nodes.map(renderBlock), "\n\n");
-}
-/** Flatten an mdast tree into Relay text plus style runs. */
-export function renderAst(ast) {
-    return renderBlocks(ast.children);
-}
-/** Flatten a Markdown string into Relay text plus style runs. */
-export function renderMarkdown(markdown) {
-    return renderAst(parseMarkdown(markdown));
-}
-/**
- * Text a caller supplied verbatim. The empty `styles` array is meaningful to
- * Relay: it marks the part as structured plain text so no client tries to read
- * it as a legacy Markdown body.
- */
-export function renderRawText(value) {
-    return { text: value, styles: [] };
-}

package/dist/src/idempotency.d.ts

@@ -1,50 +0,0 @@
-/**
- * Deterministic `Idempotency-Key` derivation for outbound sends, and the
- * `event_id` window that keeps at-least-once delivery from dispatching the
- * same inbound event twice.
- */
-/**
- * Key one outbound send against the inbound event that caused it: the event id
- * and the send's position in the turn, and nothing else.
- *
- * The content is deliberately not in the key. Relay hashes the whole request
- * server side, stores that hash beside the key, replays the stored response
- * when a retry carries the same hash, and answers 409 `idempotency_conflict`
- * when it does not. Folding the content into the key would change the key
- * whenever the body changed, so the conflict could never fire and a handler
- * whose model wrote different words the second time would post a genuine
- * second message to the person. A key that names only the position is what
- * lets Relay replay a faithful retry and refuse a diverging one.
- *
- * The prefix keeps the key at or above the 8 character floor even for an empty
- * event id, and the event id is bounded so the whole key stays under 255.
- */
-export declare function deriveIdempotencyKey(eventId: string, ordinal: number): string;
-/**
- * Key a send that no inbound event caused, such as a proactive session opened
- * against a stored thread. There is no event to key against and no way to tell
- * a deliberate repeat of the same words from a retry, so the key is unique per
- * call: it makes the request well formed without claiming a replay guarantee
- * the caller cannot have.
- */
-export declare function unkeyedIdempotencyKey(conversationId: string): string;
-/**
- * Bounded insertion-ordered set of handled `event_id` values.
- *
- * `claim` is the only way in, and it both tests and inserts with nothing
- * awaited in between, so two redeliveries of one event racing each other in
- * the same process cannot both win. The window lives in memory in one process:
- * a restart, or a second instance behind the same webhook URL, has no claim to
- * lose and will dispatch the event again. The `Idempotency-Key` on every send
- * is what makes that second dispatch harmless.
- */
-export declare class DedupeWindow {
-    private readonly capacity;
-    private readonly seen;
-    constructor(capacity: number);
-    has(id: string): boolean;
-    /** Take the event id. Answers false when it was already taken. */
-    claim(id: string): boolean;
-    /** Give the event id back, so a later delivery of it is dispatched. */
-    release(id: string): void;
-}

package/dist/src/idempotency.js

@@ -1,75 +0,0 @@
-/**
- * Deterministic `Idempotency-Key` derivation for outbound sends, and the
- * `event_id` window that keeps at-least-once delivery from dispatching the
- * same inbound event twice.
- */
-const KEY_PREFIX = "relay:";
-/** Relay requires 8 to 255 characters on the `Idempotency-Key` header. */
-const MAX_KEY_LENGTH = 255;
-/**
- * Key one outbound send against the inbound event that caused it: the event id
- * and the send's position in the turn, and nothing else.
- *
- * The content is deliberately not in the key. Relay hashes the whole request
- * server side, stores that hash beside the key, replays the stored response
- * when a retry carries the same hash, and answers 409 `idempotency_conflict`
- * when it does not. Folding the content into the key would change the key
- * whenever the body changed, so the conflict could never fire and a handler
- * whose model wrote different words the second time would post a genuine
- * second message to the person. A key that names only the position is what
- * lets Relay replay a faithful retry and refuse a diverging one.
- *
- * The prefix keeps the key at or above the 8 character floor even for an empty
- * event id, and the event id is bounded so the whole key stays under 255.
- */
-export function deriveIdempotencyKey(eventId, ordinal) {
-    const suffix = `:${ordinal}`;
-    const room = MAX_KEY_LENGTH - KEY_PREFIX.length - suffix.length;
-    return `${KEY_PREFIX}${eventId.slice(0, room)}${suffix}`;
-}
-/**
- * Key a send that no inbound event caused, such as a proactive session opened
- * against a stored thread. There is no event to key against and no way to tell
- * a deliberate repeat of the same words from a retry, so the key is unique per
- * call: it makes the request well formed without claiming a replay guarantee
- * the caller cannot have.
- */
-export function unkeyedIdempotencyKey(conversationId) {
-    return `${KEY_PREFIX}${conversationId}:${crypto.randomUUID()}`;
-}
-/**
- * Bounded insertion-ordered set of handled `event_id` values.
- *
- * `claim` is the only way in, and it both tests and inserts with nothing
- * awaited in between, so two redeliveries of one event racing each other in
- * the same process cannot both win. The window lives in memory in one process:
- * a restart, or a second instance behind the same webhook URL, has no claim to
- * lose and will dispatch the event again. The `Idempotency-Key` on every send
- * is what makes that second dispatch harmless.
- */
-export class DedupeWindow {
-    capacity;
-    seen = new Set();
-    constructor(capacity) {
-        this.capacity = capacity;
-    }
-    has(id) {
-        return this.seen.has(id);
-    }
-    /** Take the event id. Answers false when it was already taken. */
-    claim(id) {
-        if (this.seen.has(id))
-            return false;
-        this.seen.add(id);
-        if (this.seen.size > this.capacity) {
-            const oldest = this.seen.values().next().value;
-            if (oldest !== undefined)
-                this.seen.delete(oldest);
-        }
-        return true;
-    }
-    /** Give the event id back, so a later delivery of it is dispatched. */
-    release(id) {
-        this.seen.delete(id);
-    }
-}

package/dist/src/index.d.ts

@@ -1,14 +0,0 @@
-export { createRelayAdapter, RelayAdapter, RelayInvocationSpentError, RELAY_ADAPTER_NAME, } from "./adapter.js";
-export type { RelayAdapterOptions } from "./adapter.js";
-export { RelayApiError, RelayClient } from "./client.js";
-export type { RelayClientOptions, RelayHistoryOptions, RelayReactionOptions, RelaySendOptions, RelayUploadOptions, } from "./client.js";
-export { MAX_PARTS_PER_MESSAGE, MAX_TEXT_PART_BYTES, chunkRenderedText, utf8Length, } from "./chunk.js";
-export { MAX_STYLE_RANGES, renderAst, renderMarkdown, renderRawText, } from "./format.js";
-export type { RenderedText } from "./format.js";
-export { DedupeWindow, deriveIdempotencyKey, unkeyedIdempotencyKey, } from "./idempotency.js";
-export { toRelayReaction } from "./reactions.js";
-export type { RelayReaction } from "./reactions.js";
-export { decodeWebhookSecret, verifyWebhookSignature, WebhookSecretError, WebhookVerificationError, } from "./signature.js";
-export type { VerifyOptions } from "./signature.js";
-export { decodeRelayThreadId, encodeRelayThreadId, RELAY_THREAD_PREFIX, relayChannelIdFromThreadId, } from "./threadId.js";
-export type * from "./types.js";

package/dist/src/index.js

@@ -1,8 +0,0 @@
-export { createRelayAdapter, RelayAdapter, RelayInvocationSpentError, RELAY_ADAPTER_NAME, } from "./adapter.js";
-export { RelayApiError, RelayClient } from "./client.js";
-export { MAX_PARTS_PER_MESSAGE, MAX_TEXT_PART_BYTES, chunkRenderedText, utf8Length, } from "./chunk.js";
-export { MAX_STYLE_RANGES, renderAst, renderMarkdown, renderRawText, } from "./format.js";
-export { DedupeWindow, deriveIdempotencyKey, unkeyedIdempotencyKey, } from "./idempotency.js";
-export { toRelayReaction } from "./reactions.js";
-export { decodeWebhookSecret, verifyWebhookSignature, WebhookSecretError, WebhookVerificationError, } from "./signature.js";
-export { decodeRelayThreadId, encodeRelayThreadId, RELAY_THREAD_PREFIX, relayChannelIdFromThreadId, } from "./threadId.js";

package/dist/src/reactions.d.ts

@@ -1,12 +0,0 @@
-import type { EmojiValue } from "chat";
-import type { RelayReactionType } from "./types.js";
-export interface RelayReaction {
-    type: RelayReactionType;
-    emoji?: string;
-}
-/**
- * Resolve a Chat SDK reaction into Relay's `{ type, emoji }` pair. Accepts an
- * `EmojiValue`, a `:shortcode:`, a bare well-known name, the `{{emoji:name}}`
- * placeholder an `EmojiValue` stringifies to, or a literal character.
- */
-export declare function toRelayReaction(input: EmojiValue | string): RelayReaction;

package/dist/src/reactions.js

@@ -1,98 +0,0 @@
-import { DEFAULT_EMOJI_MAP } from "chat";
-/**
- * A Relay reaction is an emoji character. Relay does render it as an
- * iMessage-style balloon, but the balloon draws whatever string is stored, so
- * the character is what has to be sent. Relay once also accepted six named
- * types (love, like, dislike, laugh, emphasize, question) and stored the name
- * itself in the emoji column, which put the word "like" inside the balloon.
- * Those names are gone from the API and this adapter never produces one.
- */
-const PLACEHOLDER = /^\{\{emoji:([^}]+)\}\}$/;
-const SHORTCODE = /^:([a-z0-9_+-]+):$/i;
-/** Variation selector 16 and the five skin tone modifiers. */
-const DECORATION = /[️\u{1F3FB}-\u{1F3FF}]/gu;
-function firstFormat(value) {
-    return Array.isArray(value) ? value[0] : value;
-}
-function bare(value) {
-    return value.replace(DECORATION, "");
-}
-let literalIndex;
-/** Lazily invert the emoji map so a literal character resolves to its name. */
-function nameForLiteral(literal) {
-    if (!literalIndex) {
-        literalIndex = new Map();
-        for (const [name, formats] of Object.entries(DEFAULT_EMOJI_MAP)) {
-            const unicode = Array.isArray(formats.gchat) ? formats.gchat : [formats.gchat];
-            for (const candidate of unicode) {
-                const key = bare(candidate);
-                if (!literalIndex.has(key))
-                    literalIndex.set(key, name);
-            }
-        }
-    }
-    return literalIndex.get(bare(literal));
-}
-let slackIndex;
-function nameForAlias(alias) {
-    if (!slackIndex) {
-        slackIndex = new Map();
-        for (const [name, formats] of Object.entries(DEFAULT_EMOJI_MAP)) {
-            const aliases = Array.isArray(formats.slack) ? formats.slack : [formats.slack];
-            for (const candidate of aliases) {
-                if (!slackIndex.has(candidate))
-                    slackIndex.set(candidate, name);
-            }
-        }
-    }
-    return slackIndex.get(alias);
-}
-function isEmojiValue(value) {
-    return typeof value === "object" && value !== null && "name" in value;
-}
-/**
- * Resolve a Chat SDK reaction into Relay's `{ type, emoji }` pair. Accepts an
- * `EmojiValue`, a `:shortcode:`, a bare well-known name, the `{{emoji:name}}`
- * placeholder an `EmojiValue` stringifies to, or a literal character.
- */
-export function toRelayReaction(input) {
-    let name;
-    let literal;
-    if (isEmojiValue(input)) {
-        name = input.name;
-    }
-    else {
-        const trimmed = input.trim();
-        const placeholder = PLACEHOLDER.exec(trimmed);
-        const shortcode = SHORTCODE.exec(trimmed);
-        const candidate = placeholder?.[1] ?? shortcode?.[1] ?? trimmed;
-        if (candidate in DEFAULT_EMOJI_MAP) {
-            name = candidate;
-        }
-        else if (nameForAlias(candidate)) {
-            name = nameForAlias(candidate);
-        }
-        else if (placeholder || shortcode) {
-            throw new Error(`unknown emoji name for a Relay reaction: ${trimmed}`);
-        }
-        else {
-            literal = trimmed;
-            name = nameForLiteral(trimmed);
-        }
-    }
-    // One normalization, on both the add and the remove path, because Relay
-    // deletes a reaction by exact string match
-    // (`Relay-Server/server/src/routes/platform.ts:571-572`). Without it,
-    // `addReaction("👍🏽")` followed by `removeReaction("👍")` answers 200 and
-    // deletes nothing. A known character resolves to the map's canonical form,
-    // which keeps a variation selector where the canonical form has one; an
-    // unknown character keeps its own bare form.
-    if (name) {
-        const formats = DEFAULT_EMOJI_MAP[name];
-        if (formats)
-            return { type: "emoji", emoji: firstFormat(formats.gchat) };
-    }
-    if (literal)
-        return { type: "emoji", emoji: bare(literal) };
-    throw new Error("a Relay reaction needs an emoji character or a well-known emoji name");
-}

package/dist/src/signature.d.ts

@@ -1,46 +0,0 @@
-export interface VerifyOptions {
-    /** Maximum allowed clock skew for `webhook-timestamp`, in seconds. */
-    toleranceSeconds?: number;
-    /** Override "now" for verification (seconds since epoch). Test hook. */
-    nowSeconds?: number;
-}
-export declare class WebhookVerificationError extends Error {
-    constructor(message: string);
-}
-/**
- * The configured signing secret is unusable. This is a deployment mistake, not
- * a bad delivery, so it is a separate error: catch it where the secret is
- * configured and fail there.
- */
-export declare class WebhookSecretError extends Error {
-    constructor(message: string);
-}
-/**
- * Decode the signing secret Relay issued, with or without its `whsec_` prefix.
- *
- * `atob` answers a bare `InvalidCharacterError` on a secret that is not
- * base64, which no caller recognizes: it escapes signature verification, the
- * mount answers 500, and Relay reads that as a transient failure and redelivers
- * ten times. Name it as a `WebhookSecretError` so it can be caught once, where
- * the secret is configured, instead of on every delivery.
- */
-export declare function decodeWebhookSecret(secret: string): Uint8Array<ArrayBuffer>;
-/**
- * Verify a Standard Webhooks signature exactly as Relay signs deliveries:
- * HMAC-SHA256 over `${webhook-id}.${webhook-timestamp}.${raw body}` with the
- * base64 secret, compared against every `v1,` candidate in
- * `webhook-signature` (rotation sends two). Throws `WebhookVerificationError`
- * on any failure, and `WebhookSecretError` when the configured secret itself
- * is unusable. Uses only Web platform APIs (`crypto.subtle`, `atob`), so it
- * runs on Node 22+, Vercel Edge, and Cloudflare Workers unchanged.
- */
-export declare function verifyWebhookSignature(input: {
-    secret: string;
-    payload: string;
-    headers: {
-        "webhook-id": string | null | undefined;
-        "webhook-timestamp": string | null | undefined;
-        "webhook-signature": string | null | undefined;
-    };
-    options?: VerifyOptions;
-}): Promise<void>;

package/dist/src/signature.js

@@ -1,95 +0,0 @@
-export class WebhookVerificationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "WebhookVerificationError";
-    }
-}
-/**
- * The configured signing secret is unusable. This is a deployment mistake, not
- * a bad delivery, so it is a separate error: catch it where the secret is
- * configured and fail there.
- */
-export class WebhookSecretError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "WebhookSecretError";
-    }
-}
-const DEFAULT_TOLERANCE_SECONDS = 5 * 60;
-function base64ToBytes(value) {
-    const binary = atob(value);
-    const bytes = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i += 1)
-        bytes[i] = binary.charCodeAt(i);
-    return bytes;
-}
-/**
- * Decode the signing secret Relay issued, with or without its `whsec_` prefix.
- *
- * `atob` answers a bare `InvalidCharacterError` on a secret that is not
- * base64, which no caller recognizes: it escapes signature verification, the
- * mount answers 500, and Relay reads that as a transient failure and redelivers
- * ten times. Name it as a `WebhookSecretError` so it can be caught once, where
- * the secret is configured, instead of on every delivery.
- */
-export function decodeWebhookSecret(secret) {
-    const raw = secret.startsWith("whsec_") ? secret.slice("whsec_".length) : secret;
-    try {
-        return base64ToBytes(raw);
-    }
-    catch {
-        throw new WebhookSecretError("the webhook signing secret is not base64: pass the whsec_ value Relay issued");
-    }
-}
-function constantTimeEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    let diff = 0;
-    for (let i = 0; i < a.length; i += 1)
-        diff |= a[i] ^ b[i];
-    return diff === 0;
-}
-/**
- * Verify a Standard Webhooks signature exactly as Relay signs deliveries:
- * HMAC-SHA256 over `${webhook-id}.${webhook-timestamp}.${raw body}` with the
- * base64 secret, compared against every `v1,` candidate in
- * `webhook-signature` (rotation sends two). Throws `WebhookVerificationError`
- * on any failure, and `WebhookSecretError` when the configured secret itself
- * is unusable. Uses only Web platform APIs (`crypto.subtle`, `atob`), so it
- * runs on Node 22+, Vercel Edge, and Cloudflare Workers unchanged.
- */
-export async function verifyWebhookSignature(input) {
-    const id = input.headers["webhook-id"];
-    const timestamp = input.headers["webhook-timestamp"];
-    const signatureHeader = input.headers["webhook-signature"];
-    if (!id || !timestamp || !signatureHeader) {
-        throw new WebhookVerificationError("missing webhook signature headers");
-    }
-    const tolerance = input.options?.toleranceSeconds ?? DEFAULT_TOLERANCE_SECONDS;
-    const now = input.options?.nowSeconds ?? Math.floor(Date.now() / 1000);
-    const ts = Number(timestamp);
-    if (!Number.isFinite(ts)) {
-        throw new WebhookVerificationError("invalid webhook-timestamp");
-    }
-    if (Math.abs(now - ts) > tolerance) {
-        throw new WebhookVerificationError("webhook-timestamp outside tolerance");
-    }
-    const key = await crypto.subtle.importKey("raw", decodeWebhookSecret(input.secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const signedContent = `${id}.${timestamp}.${input.payload}`;
-    const expected = new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(signedContent)));
-    for (const candidate of signatureHeader.split(" ")) {
-        const [version, value] = candidate.split(",", 2);
-        if (version !== "v1" || !value)
-            continue;
-        let provided;
-        try {
-            provided = base64ToBytes(value);
-        }
-        catch {
-            continue;
-        }
-        if (constantTimeEqual(expected, provided))
-            return;
-    }
-    throw new WebhookVerificationError("no matching v1 signature");
-}

package/dist/src/threadId.d.ts

@@ -1,12 +0,0 @@
-import type { RelayThreadId } from "./types.js";
-/**
- * Relay thread ids are `relay:{conversation_id}`. A Relay conversation has no
- * enclosing channel, so the channel id is the same string. Both are written
- * out here rather than left to the Chat SDK defaults, because the default
- * channel derivation keeps the first two colon-separated segments and that
- * only happens to be correct for this shape.
- */
-export declare const RELAY_THREAD_PREFIX = "relay:";
-export declare function encodeRelayThreadId(platformData: RelayThreadId): string;
-export declare function decodeRelayThreadId(threadId: string): RelayThreadId;
-export declare function relayChannelIdFromThreadId(threadId: string): string;