fauna-api 0.0.0-stage → 1.0.679

package/dist/src/view.d.ts

@@ -0,0 +1,113 @@
+import * as Y from "yjs";
+import { Room, Presence, Authorization } from "./shared/server.js";
+import type { File as DriveFile } from "./drive.js";
+import type { Attachment } from "./parrot/share.js";
+/**
+ * What a file opens as in its live room: `text` and `table` are edited together,
+ * `image` is annotated together, and `view` (video, audio, PDF, anything else or
+ * too large to edit) is looked at together.
+ */
+export type Kind = 'text' | 'table' | 'image' | 'view';
+/** What you may do in a file room: `read` for share links, `write` for owners, group members and chat members. */
+export type Role = 'read' | 'write';
+/** Text and tables over this size open as `view`. */
+export declare const EDIT_MAX_BYTES: number;
+/** True for files whose bytes are text. */
+export declare function isText(contentType: string, name: string): boolean;
+/** What a file opens as, by its type, name and size. */
+export declare function kindOf(contentType: string, name: string, size: number): Kind;
+/** A mark on an image. Points run from 0 to 1 across the image's width and height. */
+export type Mark = {
+    id: string;
+    kind: 'pen' | 'box' | 'arrow' | 'note' | 'pin';
+    points: [number, number][];
+    /** A note's or pin's words. */
+    text?: string;
+    /** Who made it, by email. */
+    author: string;
+    color: string;
+    at: number;
+};
+/** Rows of cells from CSV text: quoted fields, doubled quotes and CRLF all read right. */
+export declare function parseCSV(text: string): string[][];
+/** CSV text from rows, quoting cells that need it. */
+export declare function formatCSV(rows: string[][]): string;
+/** The table's cells in order, as rows of text. */
+export declare function tableRows(doc: Y.Doc): string[][];
+/** Fill an empty table document from rows of text. */
+export declare function fillTable(doc: Y.Doc, rows: string[][]): void;
+/** Add a row (after `after`, or at the end) and return its id. */
+export declare function addRow(doc: Y.Doc, after?: string): string;
+/** Add a column (after `after`, or at the end) and return its id. */
+export declare function addColumn(doc: Y.Doc, after?: string): string;
+export declare function removeRow(doc: Y.Doc, row: string): void;
+export declare function removeColumn(doc: Y.Doc, column: string): void;
+/** A fresh document holding a file's content: its text, its CSV, or an image's marks as JSON. */
+export declare function docFrom(kind: Kind, content: Uint8Array | null): Y.Doc;
+/** What a document saves as: the text, the CSV, or the marks as JSON. */
+export declare function contentOf(kind: Kind, doc: Y.Doc): Uint8Array;
+/** Base64 for document updates on the wire. */
+export declare function toBase64(bytes: Uint8Array): string;
+export declare function fromBase64(text: string): Uint8Array;
+/** A file to open live: a Drive file (by path or share link) or a chat attachment. */
+export type Target = DriveFile | Attachment;
+export type Hooks = Partial<{
+    /** Someone joined or left, or moved their pointer or selection. */
+    onPeople(room: ViewRoom): void;
+    /** The file changed outside the room. Editable kinds get a new `doc` to rebind to; others reload the file. */
+    onReload(room: ViewRoom): void;
+    /** The room's edits were written back to the file. */
+    onSaved(room: ViewRoom): void;
+    /** The room closed or the connection dropped. Connect again to rejoin. */
+    onClosed(room: ViewRoom): void;
+}>;
+/**
+ * A live room for one file. Everyone in it sees everyone else, by seat; with
+ * `write`, edits to `doc` reach everyone and are saved back to the file.
+ * Pointers ride in each seat's position (x and y from 0 to 1, z the page) and
+ * text selections in its status.
+ */
+export declare class ViewRoom extends Room {
+    readonly target: Target;
+    kind: Kind;
+    role: Role;
+    /** You own the file: you can remove anyone's marks on it. */
+    owner: boolean;
+    /** The file as the room sees it. */
+    file: {
+        name: string;
+        contentType: string;
+        contentLength: number;
+    };
+    /** The shared document for `text`, `table` and `image`; empty for `view`. */
+    doc: Y.Doc;
+    private hooks;
+    private outgoing;
+    private timer;
+    private ended;
+    /** Edits up to this sequence number are in the file. */
+    private saved;
+    constructor(endpoint: string, ws: WebSocket, authorization: Authorization, id: string, target: Target, hooks: Hooks);
+    /** Replace or merge the room's hooks once the UI that renders it is ready. */
+    setHooks(hooks: Hooks): void;
+    /** Everyone else in the room. */
+    people(self?: Presence): Presence[];
+    /** The roster changed. */
+    peopleChanged(): void;
+    hydrate(state: any): void;
+    handleEvent(packet: any): boolean;
+    private replace;
+    /** Send edits waiting in the batch now. */
+    flush(): void;
+    /** The connection ended: stop sending, and tell the UI once. */
+    closed(): void;
+    disconnect(): void;
+}
+/**
+ * Join the live room for a file: a Drive file (by path or share link) or a chat
+ * attachment. Owners, group members and chat members can edit; share links look.
+ */
+export declare function connect(target: Target, hooks?: Hooks): Promise<{
+    room: ViewRoom;
+    self: Presence;
+}>;

package/dist/src/view.js

@@ -0,0 +1,386 @@
+import * as Y from "yjs";
+import { Fauna } from "../index.js";
+import { Room, connect as connectServer } from "./shared/server.js";
+/** Text and tables over this size open as `view`. */
+export const EDIT_MAX_BYTES = 1024 * 1024;
+const TEXT_TYPES = new Set(['application/json', 'application/xml', 'application/javascript', 'application/x-sh', 'application/x-yaml', 'application/toml', 'application/x-ndjson']);
+const TEXT_EXTENSIONS = /\.(txt|md|markdown|json|jsonl|xml|html?|css|js|mjs|cjs|jsx|ts|tsx|py|rb|go|rs|java|kt|c|h|cc|cpp|hpp|cs|php|sh|bash|zsh|sql|ya?ml|toml|ini|cfg|conf|log|env|r|swift|lua|pl|scala|vue|svelte|tsv)$/i;
+/** True for files whose bytes are text. */
+export function isText(contentType, name) {
+    return contentType.startsWith('text/') || TEXT_TYPES.has(contentType) || TEXT_EXTENSIONS.test(name);
+}
+/** What a file opens as, by its type, name and size. */
+export function kindOf(contentType, name, size) {
+    if (contentType.startsWith('image/'))
+        return 'image';
+    if (size > EDIT_MAX_BYTES)
+        return 'view';
+    if (contentType === 'text/csv' || /\.csv$/i.test(name))
+        return 'table';
+    if (isText(contentType, name))
+        return 'text';
+    return 'view';
+}
+// ─── CSV ─────────────────────────────────────────────────────────────────────
+/** Rows of cells from CSV text: quoted fields, doubled quotes and CRLF all read right. */
+export function parseCSV(text) {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quoted) {
+            if (c === '"' && text[i + 1] === '"') {
+                cell += '"';
+                i++;
+            }
+            else if (c === '"')
+                quoted = false;
+            else
+                cell += c;
+        }
+        else if (c === '"' && cell === '') {
+            quoted = true;
+        }
+        else if (c === ',') {
+            row.push(cell);
+            cell = '';
+        }
+        else if (c === '\n' || c === '\r') {
+            if (c === '\r' && text[i + 1] === '\n')
+                i++;
+            row.push(cell);
+            rows.push(row);
+            row = [];
+            cell = '';
+        }
+        else {
+            cell += c;
+        }
+    }
+    if (cell !== '' || row.length > 0) {
+        row.push(cell);
+        rows.push(row);
+    }
+    return rows;
+}
+/** CSV text from rows, quoting cells that need it. */
+export function formatCSV(rows) {
+    const quote = (cell) => /[",\r\n]/.test(cell) || /^\s|\s$/.test(cell) ? `"${cell.replace(/"/g, '""')}"` : cell;
+    return rows.map((row) => row.map(quote).join(',')).join('\n') + (rows.length ? '\n' : '');
+}
+// ─── Documents ───────────────────────────────────────────────────────────────
+//
+// text:  Y.Text 'text'
+// table: Y.Array 'columns' and Y.Array 'rows' of ids, and Y.Map 'cells' from a
+//        row id to a Y.Map of column id to the cell's text
+// image: Y.Array 'marks' of Mark
+function id() {
+    return Math.random().toString(36).slice(2, 10) + Date.now().toString(36).slice(-4);
+}
+/** The table's cells in order, as rows of text. */
+export function tableRows(doc) {
+    const columns = doc.getArray('columns').toArray();
+    const rows = doc.getArray('rows').toArray();
+    const cells = doc.getMap('cells');
+    return rows.map((row) => {
+        const map = cells.get(row);
+        return columns.map((column) => map?.get(column) ?? '');
+    });
+}
+/** Fill an empty table document from rows of text. */
+export function fillTable(doc, rows) {
+    const width = Math.max(1, ...rows.map((row) => row.length));
+    const columns = Array.from({ length: width }, id);
+    const rowIds = rows.map(id);
+    doc.transact(() => {
+        doc.getArray('columns').push(columns);
+        doc.getArray('rows').push(rowIds);
+        const cells = doc.getMap('cells');
+        rows.forEach((row, r) => {
+            const map = new Y.Map();
+            columns.forEach((column, c) => { if (row[c])
+                map.set(column, row[c]); });
+            cells.set(rowIds[r], map);
+        });
+    });
+}
+/** Add a row (after `after`, or at the end) and return its id. */
+export function addRow(doc, after) {
+    const rows = doc.getArray('rows');
+    const row = id();
+    doc.transact(() => {
+        const index = after ? rows.toArray().indexOf(after) + 1 : rows.length;
+        rows.insert(Math.max(0, Math.min(index, rows.length)), [row]);
+        doc.getMap('cells').set(row, new Y.Map());
+    });
+    return row;
+}
+/** Add a column (after `after`, or at the end) and return its id. */
+export function addColumn(doc, after) {
+    const columns = doc.getArray('columns');
+    const column = id();
+    const index = after ? columns.toArray().indexOf(after) + 1 : columns.length;
+    columns.insert(Math.max(0, Math.min(index, columns.length)), [column]);
+    return column;
+}
+export function removeRow(doc, row) {
+    const rows = doc.getArray('rows');
+    doc.transact(() => {
+        const index = rows.toArray().indexOf(row);
+        if (index >= 0)
+            rows.delete(index, 1);
+        doc.getMap('cells').delete(row);
+    });
+}
+export function removeColumn(doc, column) {
+    const columns = doc.getArray('columns');
+    const index = columns.toArray().indexOf(column);
+    if (index >= 0)
+        columns.delete(index, 1);
+}
+/** A fresh document holding a file's content: its text, its CSV, or an image's marks as JSON. */
+export function docFrom(kind, content) {
+    const doc = new Y.Doc();
+    const text = content ? new TextDecoder().decode(content) : '';
+    if (kind === 'text') {
+        doc.getText('text').insert(0, text);
+    }
+    else if (kind === 'table') {
+        fillTable(doc, parseCSV(text));
+    }
+    else if (kind === 'image') {
+        let marks = [];
+        try {
+            marks = text ? JSON.parse(text) : [];
+        }
+        catch { /* unreadable notes start empty */ }
+        doc.getArray('marks').push(Array.isArray(marks) ? marks : []);
+    }
+    return doc;
+}
+/** What a document saves as: the text, the CSV, or the marks as JSON. */
+export function contentOf(kind, doc) {
+    if (kind === 'text')
+        return new TextEncoder().encode(doc.getText('text').toString());
+    if (kind === 'table')
+        return new TextEncoder().encode(formatCSV(tableRows(doc)));
+    if (kind === 'image')
+        return new TextEncoder().encode(JSON.stringify(doc.getArray('marks').toArray()));
+    return new Uint8Array();
+}
+/** Base64 for document updates on the wire. */
+export function toBase64(bytes) {
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 0x8000)
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    return btoa(binary);
+}
+export function fromBase64(text) {
+    return Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+}
+/** Edits are sent in batches this far apart. */
+const BATCH_MS = 50;
+const REMOTE = Symbol("remote");
+/**
+ * A live room for one file. Everyone in it sees everyone else, by seat; with
+ * `write`, edits to `doc` reach everyone and are saved back to the file.
+ * Pointers ride in each seat's position (x and y from 0 to 1, z the page) and
+ * text selections in its status.
+ */
+export class ViewRoom extends Room {
+    constructor(endpoint, ws, authorization, id, target, hooks) {
+        super(endpoint, ws, authorization, id);
+        Object.defineProperty(this, "target", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "kind", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'view'
+        });
+        Object.defineProperty(this, "role", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'read'
+        });
+        /** You own the file: you can remove anyone's marks on it. */
+        Object.defineProperty(this, "owner", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** The file as the room sees it. */
+        Object.defineProperty(this, "file", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: { name: '', contentType: '', contentLength: 0 }
+        });
+        /** The shared document for `text`, `table` and `image`; empty for `view`. */
+        Object.defineProperty(this, "doc", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Y.Doc()
+        });
+        Object.defineProperty(this, "hooks", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "outgoing", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "timer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "ended", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Edits up to this sequence number are in the file. */
+        Object.defineProperty(this, "saved", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.target = target;
+        this.hooks = hooks;
+    }
+    /** Replace or merge the room's hooks once the UI that renders it is ready. */
+    setHooks(hooks) {
+        this.hooks = { ...this.hooks, ...hooks };
+    }
+    /** Everyone else in the room. */
+    people(self) {
+        return this.presences.filter((p) => p !== self && p.id !== self?.id);
+    }
+    /** The roster changed. */
+    peopleChanged() {
+        this.hooks.onPeople?.(this);
+    }
+    hydrate(state) {
+        this.kind = state?.kind ?? 'view';
+        this.role = state?.role === 'write' ? 'write' : 'read';
+        this.owner = state?.owner === true;
+        this.file = {
+            name: String(state?.file?.name ?? ''),
+            contentType: String(state?.file?.contentType ?? ''),
+            contentLength: Number(state?.file?.contentLength ?? 0),
+        };
+        this.saved = Number(state?.saved ?? 0);
+        this.replace(typeof state?.doc === 'string' ? state.doc : null);
+    }
+    handleEvent(packet) {
+        if (packet?.event === 'doc-update' && typeof packet.data?.update === 'string') {
+            Y.applyUpdate(this.doc, fromBase64(packet.data.update), REMOTE);
+            return true;
+        }
+        if (packet?.event === 'doc-reload') {
+            if (typeof packet.data?.doc === 'string')
+                this.replace(packet.data.doc);
+            this.hooks.onReload?.(this);
+            return true;
+        }
+        if (packet?.event === 'doc-saved') {
+            const saved = Number(packet.data?.saved ?? 0);
+            if (saved > this.saved) {
+                this.saved = saved;
+                this.hooks.onSaved?.(this);
+            }
+            return true;
+        }
+        return false;
+    }
+    replace(snapshot) {
+        this.doc.destroy();
+        const doc = new Y.Doc();
+        if (snapshot)
+            Y.applyUpdate(doc, fromBase64(snapshot), REMOTE);
+        doc.on('update', (update, origin) => {
+            if (origin === REMOTE || this.role !== 'write' || this.ended)
+                return;
+            this.outgoing.push(update);
+            this.timer ?? (this.timer = setTimeout(() => this.flush(), BATCH_MS));
+        });
+        this.doc = doc;
+    }
+    /** Send edits waiting in the batch now. */
+    flush() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        if (this.outgoing.length === 0)
+            return;
+        const update = this.outgoing.length === 1 ? this.outgoing[0] : Y.mergeUpdates(this.outgoing);
+        this.outgoing = [];
+        this.post({ event: 'doc-update', data: { update: toBase64(update) } });
+    }
+    /** The connection ended: stop sending, and tell the UI once. */
+    closed() {
+        if (this.ended)
+            return;
+        this.ended = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        this.hooks.onClosed?.(this);
+    }
+    disconnect() {
+        this.flush();
+        this.ended = true;
+        super.disconnect();
+    }
+}
+function authorizationFor(target) {
+    if ('ref' in target && 'chat' in target) {
+        if (target.chat && target.ref) {
+            return { authorization: target.file.authorization.authorization, server: `fauna:file:chat:${target.chat}/${target.ref}` };
+        }
+        target = target.file;
+    }
+    const auth = target.authorization;
+    if ('accessCode' in auth)
+        return { authorization: auth.authorization, accessCode: auth.accessCode };
+    if ('repository' in auth)
+        throw new Error('Repository files open in Termite.');
+    return { authorization: auth.authorization, server: `fauna:file:${auth.path}`, ...(auth.group ? { group: auth.group } : {}) };
+}
+/**
+ * Join the live room for a file: a Drive file (by path or share link) or a chat
+ * attachment. Owners, group members and chat members can edit; share links look.
+ */
+export async function connect(target, hooks = {}) {
+    let created;
+    const self = await connectServer(authorizationFor(target), `${Fauna.getURL()}/drive/live`, {
+        createRoom: (endpoint, ws, authorization, id) => {
+            created = new ViewRoom(endpoint, ws, authorization, id, target, hooks);
+            return created;
+        },
+        onConnection: (room, state) => room.hydrate(state),
+        onEvent: (room, packet) => room.handleEvent(packet),
+        onPresence: (room) => room.peopleChanged(),
+        onClosed: (room) => room.closed(),
+    });
+    const room = created;
+    room.ws.addEventListener('close', () => room.closed());
+    return { room, self };
+}

package/dist/src/webhooks.d.ts

@@ -0,0 +1,66 @@
+import { ApiKey, Credentials, Profile } from "./authentification.js";
+/** Event types a webhook can listen for: `chat.message` for groups and chats, payment events for API keys. */
+export type EventType = 'chat.message' | 'payment.succeeded' | 'payment.expired' | 'payment.refunded' | 'payment.disputed';
+/** Who a webhook belongs to: a group, one chat, or the API key making the call. */
+export type WebhookOwner = {
+    group: string;
+} | {
+    chat: string;
+} | 'key';
+/** An outbound webhook. Its events are signed and POSTed to `url`. */
+export type Webhook = {
+    id: string;
+    url: string;
+    events: EventType[];
+    created: Date;
+};
+/** What `create` resolves to. The secret is only ever returned here. */
+export type Registration = {
+    webhook: Webhook;
+    secret: string;
+};
+/** One event as POSTed to a webhook URL, with a `Fauna-Signature` header. */
+export type Delivery = {
+    id: string;
+    type: EventType;
+    /** Milliseconds since the epoch. */
+    created: number;
+    data: unknown;
+};
+/** A reaction carried by a `chat.message` event. */
+export type Reaction = {
+    emoji: string;
+    /** Position of the message reacted to. */
+    position: number;
+    on: boolean;
+};
+/** `data` of a `chat.message` event: a message sent in a chat. `group` is set when a group owns the chat. */
+export type ChatMessage = {
+    chatId: string;
+    chatName: string;
+    group?: string;
+    position: number;
+    author: Profile;
+    text: string;
+    /** Chat members tagged with `@`, never the author. */
+    mentions: Profile[];
+    /** Set when the message is a reaction, so apps can skip it. */
+    reaction?: Reaction;
+    /** Milliseconds since the epoch. */
+    created: number;
+};
+/**
+ * Register a webhook for a group or a chat you can read, or, signed in with an
+ * API key, for that key. In production `url` must be https on a public address.
+ * Pass `secret` to choose the signing secret; otherwise one is made.
+ */
+export declare function create(authorization: Credentials | ApiKey, owner: WebhookOwner, url: string, events: EventType[], secret?: string): Promise<Registration>;
+/** An owner's webhooks. Secrets are never listed. */
+export declare function list(authorization: Credentials | ApiKey, owner: WebhookOwner): Promise<Webhook[]>;
+export declare function remove(authorization: Credentials | ApiKey, id: string): Promise<void>;
+/**
+ * True when `signature` (the `Fauna-Signature` header, `t=<seconds>,v1=<hex>`)
+ * is the HMAC SHA-256 of `t.body` under `secret`, signed within `tolerance`
+ * seconds of now. Pass the raw request body, before any JSON parsing.
+ */
+export declare function verify(secret: string, body: string, signature: string, tolerance?: number): Promise<boolean>;

package/dist/src/webhooks.js

@@ -0,0 +1,78 @@
+import { Fauna } from "../index.js";
+function hydrate(raw) {
+    return { ...raw, created: new Date(raw.created) };
+}
+/**
+ * Register a webhook for a group or a chat you can read, or, signed in with an
+ * API key, for that key. In production `url` must be https on a public address.
+ * Pass `secret` to choose the signing secret; otherwise one is made.
+ */
+export async function create(authorization, owner, url, events, secret) {
+    const response = await fetch(`${Fauna.getURL()}/webhooks`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ owner, url, events, secret })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return { webhook: hydrate(raw.webhook), secret: raw.secret };
+}
+/** An owner's webhooks. Secrets are never listed. */
+export async function list(authorization, owner) {
+    const response = await fetch(`${Fauna.getURL()}/webhooks/list`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        },
+        body: JSON.stringify({ owner })
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    const raw = await response.json();
+    return raw.map(hydrate);
+}
+export async function remove(authorization, id) {
+    const response = await fetch(`${Fauna.getURL()}/webhooks/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+        headers: {
+            "Authorization": 'email' in authorization ? `Token ${authorization.token}` : `ApiKey ${authorization.id}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+}
+/**
+ * True when `signature` (the `Fauna-Signature` header, `t=<seconds>,v1=<hex>`)
+ * is the HMAC SHA-256 of `t.body` under `secret`, signed within `tolerance`
+ * seconds of now. Pass the raw request body, before any JSON parsing.
+ */
+export async function verify(secret, body, signature, tolerance = 300) {
+    const fields = new Map(signature.split(',').map((piece) => {
+        const at = piece.indexOf('=');
+        return [piece.slice(0, at).trim(), piece.slice(at + 1).trim()];
+    }));
+    const timestamp = Number(fields.get('t'));
+    const expected = fields.get('v1') ?? '';
+    if (!Number.isInteger(timestamp) || !expected)
+        return false;
+    if (Math.abs(Date.now() / 1000 - timestamp) > tolerance)
+        return false;
+    const encoder = new TextEncoder();
+    const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const digest = new Uint8Array(await crypto.subtle.sign('HMAC', key, encoder.encode(`${timestamp}.${body}`)));
+    const actual = [...digest].map((byte) => byte.toString(16).padStart(2, '0')).join('');
+    if (actual.length !== expected.length)
+        return false;
+    let difference = 0;
+    for (let i = 0; i < actual.length; i++)
+        difference |= actual.charCodeAt(i) ^ expected.charCodeAt(i);
+    return difference === 0;
+}

package/dist/ui.d.ts

@@ -0,0 +1 @@
+export { UI } from "./src/ui/index.js";

package/dist/ui.js

@@ -0,0 +1 @@
+export { UI } from "./src/ui/index.js";