pushnow-sdk 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { Archive, AuthorizedConfig } from './types.js';
+export declare function validateAPIURL(value: string): string;
+export declare function validateArchive(value: unknown): Archive;
+/** Structural validation only. finishLogin pins identity; recipientsV2 verifies signed bindings. */
+export declare function validateConfig(value: unknown): AuthorizedConfig;

package/dist/config.js

@@ -0,0 +1,33 @@
+import { decode, object, uuid } from './encoding.js';
+export function validateAPIURL(value) {
+    const url = new URL(value);
+    if (url.username || url.password || url.search || url.hash || url.pathname !== '/' ||
+        (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)))) {
+        throw new Error('Use an HTTPS API origin (HTTP is allowed only on localhost)');
+    }
+    return url.origin;
+}
+export function validateArchive(value) {
+    const archive = object(value);
+    uuid(archive.id);
+    decode(archive.public_key, 65);
+    decode(archive.certificate, 64);
+    return { id: archive.id, public_key: archive.public_key, certificate: archive.certificate };
+}
+/** Structural validation only. finishLogin pins identity; recipientsV2 verifies signed bindings. */
+export function validateConfig(value) {
+    const config = object(value);
+    for (const field of ['api_url', 'user_id', 'source_id', 'source_key', 'identity_public_key', 'sender_private_key']) {
+        if (typeof config[field] !== 'string' || !config[field] || /[\r\n]/.test(config[field]))
+            throw new Error(`Missing or invalid config field: ${field}`);
+    }
+    uuid(config.user_id);
+    uuid(config.source_id);
+    if (!/^[\x21-\x7e]{1,2048}$/.test(config.source_key))
+        throw new Error('Invalid source credential');
+    decode(config.identity_public_key, 65);
+    decode(config.sender_private_key, 32);
+    return { api_url: validateAPIURL(config.api_url), user_id: config.user_id, source_id: config.source_id,
+        source_key: config.source_key, identity_public_key: config.identity_public_key,
+        sender_private_key: config.sender_private_key, archive: validateArchive(config.archive) };
+}

package/dist/crypto.d.ts

@@ -0,0 +1,10 @@
+import { CipherSuite } from '@hpke/core';
+import type { Archive, AuthorizedConfig, Envelope, PendingLogin } from './types.js';
+export declare const suite: CipherSuite;
+export declare const v2AAD: (purpose: string, config: AuthorizedConfig, messageID: string, archiveID: string) => Uint8Array<ArrayBuffer>;
+export declare function generateAgreementKey(): Promise<PendingLogin['key']>;
+export declare function senderPublicKey(privateKey: string): Promise<string>;
+export declare function verifyCertificate(root: string, kind: 'source' | 'device' | 'archive', userID: string, id: string, publicKey: string, signature: string): Promise<boolean>;
+export declare function verifyArchive(config: AuthorizedConfig, value: unknown): Promise<Archive>;
+export declare function sealV2(config: AuthorizedConfig, archive: Archive, purpose: string, messageID: string, plaintext: unknown): Promise<Envelope>;
+export declare function openSenderGrant(pending: PendingLogin, grant: Envelope): Promise<unknown>;

package/dist/crypto.js

@@ -0,0 +1,59 @@
+import { Aes256Gcm, CipherSuite, DhkemP256HkdfSha256, HkdfSha256 } from '@hpke/core';
+import { base64, bytes, cryptoAPI, decode } from './encoding.js';
+import { validateArchive } from './config.js';
+export const suite = new CipherSuite({ kem: new DhkemP256HkdfSha256(), kdf: new HkdfSha256(), aead: new Aes256Gcm() });
+export const v2AAD = (purpose, config, messageID, archiveID) => bytes(JSON.stringify([2, purpose, config.user_id, config.source_id, messageID, archiveID]));
+export async function generateAgreementKey() {
+    cryptoAPI();
+    const pair = await suite.kem.generateKeyPair();
+    return { privateKey: base64(await suite.kem.serializePrivateKey(pair.privateKey)), publicKey: base64(await suite.kem.serializePublicKey(pair.publicKey)) };
+}
+export async function senderPublicKey(privateKey) {
+    const key = await suite.kem.deserializePrivateKey(decode(privateKey, 32));
+    const jwk = await cryptoAPI().subtle.exportKey('jwk', key);
+    if (!jwk.x || !jwk.y)
+        throw new Error('Sender key cannot be derived');
+    const publicJWK = { kty: 'EC', crv: 'P-256', x: jwk.x, y: jwk.y };
+    const pub = await cryptoAPI().subtle.importKey('jwk', publicJWK, { name: 'ECDH', namedCurve: 'P-256' }, true, []);
+    return base64(await cryptoAPI().subtle.exportKey('raw', pub));
+}
+export async function verifyCertificate(root, kind, userID, id, publicKey, signature) {
+    try {
+        const key = await cryptoAPI().subtle.importKey('raw', decode(root, 65), { name: 'ECDSA', namedCurve: 'P-256' }, false, ['verify']);
+        await cryptoAPI().subtle.importKey('raw', decode(publicKey, 65), { name: 'ECDH', namedCurve: 'P-256' }, false, []);
+        return await cryptoAPI().subtle.verify({ name: 'ECDSA', hash: 'SHA-256' }, key, decode(signature, 64), bytes(`pushnow-${kind}-v1\n${userID}\n${id}\n${publicKey}`));
+    }
+    catch {
+        return false;
+    }
+}
+export async function verifyArchive(config, value) {
+    const archive = validateArchive(value);
+    if (archive.id !== config.archive.id || archive.public_key !== config.archive.public_key ||
+        !await verifyCertificate(config.identity_public_key, 'archive', config.user_id, archive.id, archive.public_key, archive.certificate))
+        throw new Error('Invalid or changed account archive');
+    return archive;
+}
+export async function sealV2(config, archive, purpose, messageID, plaintext) {
+    cryptoAPI();
+    const sender = await suite.createSenderContext({ recipientPublicKey: await suite.kem.deserializePublicKey(decode(archive.public_key, 65)),
+        senderKey: await suite.kem.deserializePrivateKey(decode(config.sender_private_key, 32)), info: bytes('pushnow-v2') });
+    return { enc: base64(sender.enc), ciphertext: base64(await sender.seal(bytes(JSON.stringify(plaintext)), v2AAD(purpose, config, messageID, archive.id))) };
+}
+export async function openSenderGrant(pending, grant) {
+    const ciphertext = decode(grant.ciphertext);
+    if (ciphertext.length > 8192 || ciphertext.length < 16)
+        throw new Error('Invalid authorization grant size');
+    const recipient = await suite.createRecipientContext({ recipientKey: await suite.kem.deserializePrivateKey(decode(pending.key.privateKey, 32)),
+        enc: decode(grant.enc, 65), info: bytes('pushnow-sender-grant-v2') });
+    const plaintext = new Uint8Array(await recipient.open(ciphertext, bytes(JSON.stringify([2, 'sender-grant', pending.authorization.id, pending.key.publicKey]))));
+    try {
+        return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(plaintext));
+    }
+    catch {
+        throw new Error('Invalid authorization grant');
+    }
+    finally {
+        plaintext.fill(0);
+    }
+}

package/dist/encoding.d.ts

@@ -0,0 +1,8 @@
+export declare const bytes: (value: string) => Uint8Array<ArrayBuffer>;
+export declare function base64(value: ArrayBuffer | Uint8Array): string;
+export declare function decode(value: unknown, size?: number): Uint8Array<ArrayBuffer>;
+export declare function cryptoAPI(): Crypto;
+export declare function sha256(data: Uint8Array<ArrayBuffer>): Promise<string>;
+export declare const fingerprint: (key: string) => Promise<string>;
+export declare function uuid(value: unknown): asserts value is string;
+export declare function object(value: unknown): Record<string, unknown>;

package/dist/encoding.js

@@ -0,0 +1,34 @@
+export const bytes = (value) => new TextEncoder().encode(value);
+export function base64(value) {
+    const data = value instanceof Uint8Array ? value : new Uint8Array(value);
+    let result = '';
+    for (let start = 0; start < data.length; start += 8192)
+        result += String.fromCharCode(...data.subarray(start, start + 8192));
+    return btoa(result);
+}
+export function decode(value, size) {
+    if (typeof value !== 'string' || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+        throw new Error('Invalid Base64 encoding');
+    const decoded = Uint8Array.from(atob(value), c => c.charCodeAt(0));
+    if ((size !== undefined && decoded.length !== size) || base64(decoded) !== value)
+        throw new Error('Invalid key or encoding');
+    return decoded;
+}
+export function cryptoAPI() {
+    if (!globalThis.crypto?.subtle)
+        throw new Error('WebCrypto is required; use a secure HTTPS context');
+    return globalThis.crypto;
+}
+export async function sha256(data) {
+    return [...new Uint8Array(await cryptoAPI().subtle.digest('SHA-256', data))].map(n => n.toString(16).padStart(2, '0')).join('');
+}
+export const fingerprint = (key) => sha256(decode(key, 65));
+export function uuid(value) {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value))
+        throw new Error('Invalid UUID');
+}
+export function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Expected an object');
+    return value;
+}

package/dist/http.d.ts

@@ -0,0 +1,15 @@
+import type { AuthorizedConfig, RequestEvent, RequestOptions } from './types.js';
+export declare class APIError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+type HTTPOptions = RequestOptions & {
+    token?: string;
+    method?: RequestEvent['method'];
+    body?: unknown;
+    binary?: boolean;
+    messageID?: string;
+};
+export declare function request(apiURL: string, path: string, options?: HTTPOptions): Promise<unknown>;
+export declare function authenticated(config: AuthorizedConfig, path: string, options?: Omit<HTTPOptions, 'token'>): Promise<unknown>;
+export {};

package/dist/http.js

@@ -0,0 +1,101 @@
+import { validateAPIURL, validateConfig } from './config.js';
+export class APIError extends Error {
+    status;
+    constructor(status) {
+        super(`PushNow API request failed (HTTP ${status})`);
+        this.status = status;
+        this.name = 'APIError';
+    }
+}
+function pathTemplate(path) {
+    return path.replace(/\/authorizations\/[^/]+\/token$/, '/authorizations/:id/token').replace(/\/attachments\/[^/]+$/, '/attachments/:id');
+}
+async function json(response) {
+    if (!response.body)
+        throw new Error('Missing API response');
+    const reader = response.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const part = await reader.read();
+            if (part.done)
+                break;
+            size += part.value.length;
+            if (size > 2 * 1024 * 1024) {
+                await reader.cancel();
+                throw new Error('API response is too large');
+            }
+            chunks.push(part.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const data = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        data.set(chunk, offset);
+        offset += chunk.length;
+    }
+    try {
+        return JSON.parse(new TextDecoder().decode(data));
+    }
+    catch {
+        throw new Error('Invalid API JSON response');
+    }
+}
+export async function request(apiURL, path, options = {}) {
+    const origin = validateAPIURL(apiURL), method = options.method ?? 'GET';
+    const started = Date.now(), controller = new AbortController();
+    let status = null, outcome = 'network_error';
+    const abort = () => controller.abort();
+    options.signal?.addEventListener('abort', abort, { once: true });
+    if (options.signal?.aborted)
+        controller.abort();
+    const timer = setTimeout(abort, 30000);
+    try {
+        controller.signal.throwIfAborted();
+        const headers = {};
+        if (options.token)
+            headers.authorization = `Bearer ${options.token}`;
+        if (options.body !== undefined)
+            headers['content-type'] = options.binary ? 'application/octet-stream' : 'application/json';
+        if (options.messageID)
+            headers['idempotency-key'] = options.messageID;
+        const response = await (options.fetcher ?? fetch)(new URL(path, origin), { method, headers, redirect: 'error',
+            credentials: 'omit', cache: 'no-store', signal: controller.signal,
+            ...(options.body === undefined ? {} : { body: options.binary ? options.body : JSON.stringify(options.body) }) });
+        status = response.status;
+        if (!response.ok) {
+            outcome = 'http_error';
+            await response.body?.cancel();
+            throw new APIError(status);
+        }
+        const result = status === 204 ? null : await json(response);
+        outcome = 'success';
+        return result;
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            outcome = 'aborted';
+            throw new DOMException('Request aborted or timed out', 'AbortError');
+        }
+        if (error instanceof APIError)
+            throw error;
+        // Fetch/JSON error messages can include URLs or response data. Do not forward them.
+        throw new Error('PushNow request failed or returned an invalid response');
+    }
+    finally {
+        clearTimeout(timer);
+        options.signal?.removeEventListener('abort', abort);
+        try {
+            void Promise.resolve(options.onRequest?.(Object.freeze({ method, path: pathTemplate(path), status,
+                durationMs: Math.max(0, Date.now() - started), outcome }))).catch(() => { });
+        }
+        catch { /* Observability must not change delivery. */ }
+    }
+}
+export function authenticated(config, path, options = {}) {
+    const validated = validateConfig(config);
+    return request(validated.api_url, path, { ...options, token: validated.source_key });
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { beginLogin, finishLogin, beginAccountLogin, finishAccountLogin } from './auth.js';
+export { validateConfig } from './config.js';
+export { recipientsV2 } from './recipients.js';
+export { prepareMessageV2, submitMessageV2 } from './messages.js';
+export { uploadAttachment } from './attachments.js';
+export { sendNotification } from './send.js';
+export { APIError } from './http.js';
+export { fingerprint } from './encoding.js';
+export type * from './types.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { beginLogin, finishLogin, beginAccountLogin, finishAccountLogin } from './auth.js';
+export { validateConfig } from './config.js';
+export { recipientsV2 } from './recipients.js';
+export { prepareMessageV2, submitMessageV2 } from './messages.js';
+export { uploadAttachment } from './attachments.js';
+export { sendNotification } from './send.js';
+export { APIError } from './http.js';
+export { fingerprint } from './encoding.js';

package/dist/messages.d.ts

@@ -0,0 +1,5 @@
+import type { AuthorizedConfig, MessageContent, MessageOptions, PreparedMessage, RecipientDirectory, RequestOptions, SubmitResult } from './types.js';
+export declare function validateContent(input: MessageContent): Required<Pick<MessageContent, 'title' | 'body' | 'links' | 'attachments'>> & MessageContent;
+export declare function validateMessageOptions(options: MessageOptions): MessageOptions;
+export declare function prepareMessageV2(input: AuthorizedConfig, inputDirectory: RecipientDirectory, plaintext: MessageContent, inputOptions?: MessageOptions): Promise<PreparedMessage>;
+export declare function submitMessageV2(input: AuthorizedConfig, message: PreparedMessage, options?: RequestOptions): Promise<SubmitResult>;

package/dist/messages.js

@@ -0,0 +1,132 @@
+import { validateConfig } from './config.js';
+import { sealV2 } from './crypto.js';
+import { bytes, cryptoAPI, decode, object, uuid } from './encoding.js';
+import { authenticated } from './http.js';
+import { validateDescriptor } from './attachments.js';
+import { verifyDirectory } from './recipients.js';
+const bindings = new WeakMap();
+const binding = (config) => JSON.stringify([config.api_url, config.user_id, config.source_id, config.identity_public_key, config.sender_private_key, config.archive.id, config.archive.public_key]);
+export function validateContent(input) {
+    const value = object(input);
+    if (Object.keys(value).some(k => !['title', 'body', 'links', 'attachments', 'image_id', 'icon_id'].includes(k)))
+        throw new Error('Unsupported message content field; pass routing fields such as sound in MessageOptions');
+    if (typeof value.title !== 'string' || typeof value.body !== 'string')
+        throw new Error('Message needs title and body');
+    const links = value.links ?? [], attachments = value.attachments ?? [];
+    if (!Array.isArray(links) || links.some(link => typeof link !== 'string') || !Array.isArray(attachments) || attachments.length > 20)
+        throw new Error('Invalid links or attachment count');
+    const descriptors = attachments.map(validateDescriptor), ids = new Set(descriptors.map(d => d.id));
+    if (ids.size !== descriptors.length)
+        throw new Error('Duplicate attachment');
+    for (const id of [value.image_id, value.icon_id])
+        if (id !== undefined) {
+            uuid(id);
+            if (!ids.has(id))
+                throw new Error('Image and icon must refer to an attached file');
+        }
+    const full = { title: value.title, body: value.body, links: [...links], attachments: descriptors,
+        ...(value.image_id === undefined ? {} : { image_id: value.image_id }), ...(value.icon_id === undefined ? {} : { icon_id: value.icon_id }) };
+    if (bytes(JSON.stringify(full)).length + 16 > 256 * 1024)
+        throw new Error('Encrypted message manifest exceeds 256 KiB');
+    return full;
+}
+function timestamp(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new Error('Invalid ISO timestamp');
+    const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})(?:\.(\d{1,3}))?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+    if (!match)
+        throw new Error('Invalid ISO timestamp');
+    const local = `${match[1]}T${match[2]}.${(match[3] ?? '').padEnd(3, '0')}Z`;
+    if (!Number.isFinite(Date.parse(value)) || !Number.isFinite(Date.parse(local)) || new Date(local).toISOString() !== local)
+        throw new Error('Invalid ISO timestamp');
+    return new Date(value).toISOString();
+}
+export function validateMessageOptions(options) {
+    if (options.sound !== undefined && !['default', 'silent', 'chime'].includes(options.sound))
+        throw new Error('Invalid sound; use default, silent or chime');
+    if (options.inboxOnly !== undefined && typeof options.inboxOnly !== 'boolean')
+        throw new Error('inboxOnly must be boolean');
+    if (options.inboxOnly && options.deviceIds !== undefined)
+        throw new Error('Choose inboxOnly or deviceIds, not both');
+    if (options.deviceIds !== undefined) {
+        if (!Array.isArray(options.deviceIds) || options.deviceIds.length > 100)
+            throw new Error('Invalid target count');
+        options.deviceIds.forEach(uuid);
+        if (new Set(options.deviceIds).size !== options.deviceIds.length)
+            throw new Error('Duplicate target');
+    }
+    if (options.messageID !== undefined)
+        uuid(options.messageID);
+    if (options.sourceKind !== undefined && !["web", "cli", "api", "subscription"].includes(options.sourceKind))
+        throw new Error("Invalid source kind");
+    const scheduledAt = timestamp(options.scheduledAt), expiresAt = timestamp(options.expiresAt), now = Date.now(), end = now + 30 * 86400000;
+    if (scheduledAt && (Date.parse(scheduledAt) <= now || Date.parse(scheduledAt) > end))
+        throw new Error('Schedule must be in the next 30 days');
+    if (expiresAt && (Date.parse(expiresAt) <= (scheduledAt ? Date.parse(scheduledAt) : now) || Date.parse(expiresAt) > end))
+        throw new Error('Expiry must follow delivery and be within 30 days');
+    return { ...options, deviceIds: options.deviceIds && [...options.deviceIds], scheduledAt, expiresAt };
+}
+function truncateUTF8(value, limit) {
+    let result = '', size = 0;
+    for (const char of value) {
+        const n = bytes(char).length;
+        if (size + n > limit)
+            break;
+        result += char;
+        size += n;
+    }
+    return result;
+}
+export async function prepareMessageV2(input, inputDirectory, plaintext, inputOptions = {}) {
+    const config = validateConfig(input), full = validateContent(plaintext), options = validateMessageOptions(inputOptions);
+    const directory = await verifyDirectory(config, inputDirectory), messageID = options.messageID ?? cryptoAPI().randomUUID();
+    let notify;
+    if (options.inboxOnly)
+        notify = [];
+    else if (options.deviceIds !== undefined) {
+        const selected = directory.devices.filter(d => options.deviceIds.includes(d.id));
+        if (selected.length !== options.deviceIds.length)
+            throw new Error('Unknown notification device');
+        notify = selected.filter(d => d.notifications_enabled).map(d => d.id);
+    }
+    const encrypted = await sealV2(config, directory.archive, 'message', messageID, full);
+    const previewData = { title: truncateUTF8(full.title, 400), body: truncateUTF8(full.body, 700) };
+    const image = full.attachments.find(a => a.id === full.image_id);
+    if (image && bytes(JSON.stringify(image)).length <= 600)
+        previewData.image = image;
+    // Budget for the longest supported APNs filename, including legacy/default requests.
+    const previewSize = (envelope) => bytes(JSON.stringify({ aps: { alert: { title: 'PushNow', body: 'You have a new encrypted reminder.' }, 'mutable-content': 1, sound: 'pushnow-chime.wav' },
+        secure_v2: { message_id: messageID, user_id: config.user_id, source_id: config.source_id, archive_id: directory.archive.id,
+            device_id: '00000000-0000-0000-0000-000000000000', ...envelope, source_public_key: directory.source_public_key,
+            source_certificate: directory.source_certificate, created_at: new Date().toISOString(), read_at: null } })).length;
+    let preview = await sealV2(config, directory.archive, 'preview', messageID, previewData);
+    if (previewSize(preview) > 3900 || decode(preview.ciphertext).length > 2400) {
+        delete previewData.image;
+        preview = await sealV2(config, directory.archive, 'preview', messageID, previewData);
+    }
+    if (previewSize(preview) > 3900 || decode(preview.ciphertext).length > 2400)
+        throw new Error('Encrypted preview is too large');
+    const message = { message_id: messageID, archive_id: directory.archive.id, ...encrypted, preview,
+        attachment_ids: full.attachments.map(a => a.id), ...(notify === undefined ? {} : { notify_device_ids: notify }),
+        ...(options.sourceKind === undefined ? {} : { source_kind: options.sourceKind }),
+        ...(options.scheduledAt === undefined ? {} : { scheduled_at: options.scheduledAt }), ...(options.expiresAt === undefined ? {} : { expires_at: options.expiresAt }),
+        ...(options.sound === undefined ? {} : { sound: options.sound }) };
+    Object.freeze(message.preview);
+    Object.freeze(message.attachment_ids);
+    if (message.notify_device_ids)
+        Object.freeze(message.notify_device_ids);
+    Object.freeze(message);
+    bindings.set(message, binding(config));
+    return message;
+}
+export async function submitMessageV2(input, message, options = {}) {
+    const config = validateConfig(input);
+    if (bindings.get(message) !== binding(config))
+        throw new Error('Use the original prepared message with its authorized account and source');
+    const result = object(await authenticated(config, '/v2/messages', { ...options, method: 'POST', messageID: message.message_id, body: message }));
+    if (result.message_id !== message.message_id || typeof result.deduplicated !== 'boolean')
+        throw new Error('Invalid message response');
+    return { message_id: result.message_id, deduplicated: result.deduplicated };
+}

package/dist/recipients.d.ts

@@ -0,0 +1,3 @@
+import type { AuthorizedConfig, RecipientDirectory, RequestOptions } from './types.js';
+export declare function verifyDirectory(input: AuthorizedConfig, value: unknown): Promise<RecipientDirectory>;
+export declare function recipientsV2(input: AuthorizedConfig, options?: RequestOptions): Promise<RecipientDirectory>;

package/dist/recipients.js

@@ -0,0 +1,32 @@
+import { validateConfig } from './config.js';
+import { senderPublicKey, verifyArchive, verifyCertificate } from './crypto.js';
+import { object, uuid } from './encoding.js';
+import { authenticated } from './http.js';
+export async function verifyDirectory(input, value) {
+    const config = validateConfig(input), directory = object(structuredClone(value));
+    if (directory.user_id !== config.user_id || directory.source_id !== config.source_id || directory.identity_public_key !== config.identity_public_key)
+        throw new Error('Account or source identity changed');
+    if (typeof directory.source_public_key !== 'string' || typeof directory.source_certificate !== 'string' ||
+        !await verifyCertificate(config.identity_public_key, 'source', config.user_id, config.source_id, directory.source_public_key, directory.source_certificate))
+        throw new Error('Invalid source certificate');
+    if (await senderPublicKey(config.sender_private_key) !== directory.source_public_key)
+        throw new Error('Sender key does not match source');
+    await verifyArchive(config, directory.archive);
+    if (!Array.isArray(directory.devices) || directory.devices.length > 1000)
+        throw new Error('Invalid device directory');
+    const ids = new Set();
+    for (const value of directory.devices) {
+        const d = object(value);
+        uuid(d.id);
+        if (ids.has(d.id) || d.user_id !== config.user_id || d.status !== 'active' || typeof d.notifications_enabled !== 'boolean' ||
+            typeof d.name !== 'string' || typeof d.platform !== 'string' || typeof d.public_key !== 'string' || typeof d.certificate !== 'string' ||
+            !await verifyCertificate(config.identity_public_key, 'device', config.user_id, d.id, d.public_key, d.certificate))
+            throw new Error('Invalid device certificate or metadata');
+        ids.add(d.id);
+    }
+    return directory;
+}
+export async function recipientsV2(input, options = {}) {
+    const config = validateConfig(input);
+    return verifyDirectory(config, await authenticated(config, '/v2/recipients', options));
+}

package/dist/send.d.ts

@@ -0,0 +1,2 @@
+import type { AuthorizedConfig, NotificationInput, SendOptions, SubmitResult } from './types.js';
+export declare function sendNotification(input: AuthorizedConfig, notification: NotificationInput, inputOptions?: SendOptions): Promise<SubmitResult>;

package/dist/send.js

@@ -0,0 +1,37 @@
+import { uploadAttachment, validateAttachmentData, validateAttachmentMetadata } from './attachments.js';
+import { validateConfig } from './config.js';
+import { prepareMessageV2, submitMessageV2, validateContent, validateMessageOptions } from './messages.js';
+import { recipientsV2 } from './recipients.js';
+export async function sendNotification(input, notification, inputOptions = {}) {
+    const config = validateConfig(input), options = { ...inputOptions, ...validateMessageOptions(inputOptions) };
+    const { files = [], image, icon, ...content } = notification;
+    const full = validateContent(content);
+    if (!Array.isArray(files))
+        throw new Error('files must be an array');
+    if ((image && full.image_id) || (icon && full.icon_id))
+        throw new Error('Choose a file upload or an existing attachment ID');
+    const uploads = [...files, ...(image ? [image] : []), ...(icon ? [icon] : [])].map(file => {
+        const meta = validateAttachmentMetadata(file);
+        validateAttachmentData(file.data);
+        return { ...meta, data: file.data };
+    });
+    if (full.attachments.length + uploads.length > 20)
+        throw new Error('Maximum 20 attachments per notification');
+    const knownIDs = [...full.attachments.map(a => a.id), ...uploads.flatMap(a => a.id ? [a.id] : [])];
+    if (new Set(knownIDs).size !== knownIDs.length)
+        throw new Error('Duplicate attachment');
+    const directory = await recipientsV2(config, options);
+    if (options.deviceIds?.some(id => !directory.devices.some(d => d.id === id)))
+        throw new Error('Unknown notification device');
+    for (let index = 0; index < uploads.length; index++) {
+        const file = uploads[index];
+        const descriptor = await uploadAttachment(config, file.data, file, options);
+        full.attachments.push(descriptor);
+        if (image && index === files.length)
+            full.image_id = descriptor.id;
+        if (icon && index === files.length + (image ? 1 : 0))
+            full.icon_id = descriptor.id;
+    }
+    const message = await prepareMessageV2(config, directory, full, options);
+    return submitMessageV2(config, message, options);
+}